home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
User's Choice Windows CD
/
User's Choice Windows CD (CMS Software)(1993).iso
/
utility2
/
wine02bx.zip
/
ETC
/
DOC
< prev
next >
Wrap
Text File
|
1993-03-28
|
234KB
|
5,834 lines
Fmake-abbrev-table
Create a new, empty abbrev table object.
arguments:()
Fclear-abbrev-table
Undefine all abbrevs in abbrev table TABLE, leaving it empty.
arguments:(table)
Fdefine-abbrev
Define an abbrev in TABLE named NAME, to expand to EXPANSION and call HOOK.
NAME and EXPANSION are strings.
To undefine an abbrev, define it with EXPANSION = nil.
If HOOK is non-nil, it should be a function of no arguments;
it is called after EXPANSION is inserted.
arguments:(table name expansion &optional hook count)
Fdefine-global-abbrev
Define ABBREV as a global abbreviation for EXPANSION.
arguments:(name expansion)
Fdefine-mode-abbrev
Define ABBREV as a mode-specific abbreviation for EXPANSION.
arguments:(name expansion)
Fabbrev-symbol
Return the symbol representing abbrev named ABBREV.
This symbol's name is ABBREV, but it is not the canonical symbol of that name;
it is interned in an abbrev-table rather than the normal obarray.
The value is nil if that abbrev is not defined.
Optional second arg TABLE is abbrev table to look it up in.
The default is to try buffer's mode-specific abbrev table, then global table.
arguments:(abbrev &optional table)
Fabbrev-expansion
Return the string that ABBREV expands into in the current buffer.
Optionally specify an abbrev table as second arg;
then ABBREV is looked up in that table only.
arguments:(abbrev &optional table)
Fexpand-abbrev
Expand the abbrev before point, if there is an abbrev there.
Effective when explicitly called even when `abbrev-mode' is nil.
Returns t if expansion took place.
arguments:()
Funexpand-abbrev
Undo the expansion of the last abbrev that expanded.
This differs from ordinary undo in that other editing done since then
is not undone.
arguments:()
Finsert-abbrev-table-description
Insert before point a full description of abbrev table named NAME.
NAME is a symbol whose value is an abbrev table.
If optional 2nd arg HUMAN is non-nil, a human-readable description is inserted.
Otherwise the description is an expression,
a call to `define-abbrev-table', which would
define the abbrev table NAME exactly as it is currently defined.
arguments:(name &optional readable)
Fdefine-abbrev-table
Define TABNAME (a symbol) as an abbrev table name.
Define abbrevs in it according to DEFINITIONS, which is a list of elements
of the form (ABBREVNAME EXPANSION HOOK USECOUNT).
arguments:(tabname defns)
Vabbrev-table-name-list
List of symbols whose values are abbrev tables.Vglobal-abbrev-table
The abbrev table whose abbrevs affect all buffers.
Each buffer may also have a local abbrev table.
If it does, the local table overrides the global one
for any particular abbrev defined in both.Vfundamental-mode-abbrev-table
The abbrev table of mode-specific abbrevs for Fundamental Mode.Vlast-abbrev
The abbrev-symbol of the last abbrev expanded. See `abbrev-symbol'.Vlast-abbrev-text
The exact text of the last abbrev expanded.
nil if the abbrev has already been unexpanded.Vlast-abbrev-location
The location of the start of the last abbrev expanded.Vabbrev-start-location
Buffer position for `expand-abbrev' to use as the start of the abbrev.
nil means use the word before point as the abbrev.
Calling `expand-abbrev' sets this to nil.Vabbrev-start-location-buffer
Buffer that `abbrev-start-location' has been set for.
Trying to expand an abbrev in any other buffer clears `abbrev-start-location'.Vabbrevs-changed
Set non-nil by defining or altering any word abbrevs.
This causes `save-some-buffers' to offer to save the abbrevs.Vabbrev-all-caps
*Set non-nil means expand multi-word abbrevs all caps if abbrev was so.Vpre-abbrev-expand-hook
Function or functions to be called before abbrev expansion is done.
This is the first thing that `expand-abbrev' does, and so this may change
the current abbrev table before abbrev lookup happens.Fcons
Create a new cons, give it CAR and CDR as components, and return it.
arguments:(car cdr)
Flist
Return a newly created list with specified arguments as elements.
Any number of arguments, even zero arguments, are allowed.
arguments: (&rest args)
Fmake-list
Return a newly created list of length LENGTH, with each element being INIT.
arguments:(length init)
Fmake-vector
Return a newly created vector of length LENGTH, with each element being INIT.
See also the function `vector'.
arguments:(length init)
Fvector
Return a newly created vector with specified arguments as elements.
Any number of arguments, even zero arguments, are allowed.
arguments: (&rest args)
Fmake-byte-code
Create a byte-code object with specified arguments as elements.
At least four arguments are required; only six have any significance.
arguments: (arg1 arg2 arg3 arg4 &rest args)
Fmake-symbol
Return a newly allocated uninterned symbol whose name is NAME.
Its value and function definition are void, and its property list is nil.
arguments:(str)
Fmake-marker
Return a newly allocated marker which does not point at any place.
arguments:()
Fmake-string
Return a newly created string of length LENGTH, with each element being INIT.
Both LENGTH and INIT must be numbers.
arguments:(length init)
Fpurecopy
Make a copy of OBJECT in pure storage.
Recursively copies contents of vectors and cons cells.
Does not copy symbols.
arguments:(obj)
Fgarbage-collect
Reclaim storage for Lisp objects no longer needed.
Returns info on amount of space in use:
((USED-CONSES . FREE-CONSES) (USED-SYMS . FREE-SYMS)
(USED-MARKERS . FREE-MARKERS) USED-STRING-CHARS USED-VECTOR-SLOTS
(USED-FLOATS . FREE-FLOATS) (USED-EVENTS . FREE-EVENTS))
Garbage collection happens automatically if you cons more than
`gc-cons-threshold' bytes of Lisp data since previous garbage collection.
arguments:()
Vgc-cons-threshold
*Number of bytes of consing between garbage collections.
Garbage collection can happen automatically once this many bytes have been
allocated since the last garbage collection. All data types count.
Garbage collection happens automatically when `eval' or `funcall' are
called. (Note that `funcall' is called implicitly.)
By binding this temporarily to a large number, you can effectively
prevent garbage collection during a part of the program.Vpure-bytes-used
Number of bytes of sharable Lisp data allocated so far.Vdata-bytes-used
Number of bytes of unshared memory allocated in this session.Vdata-bytes-free
Number of bytes of unshared memory remaining available in this session.Vpurify-flag
Non-nil means loading Lisp code in order to dump an executable.
This means that certain objects should be allocated in shared (pure) space.Vundo-threshold
Keep no more undo information once it exceeds this size.
This threshold is applied when garbage collection happens.
The size is counted as the number of bytes occupied,
which includes both saved text and other data.Vundo-high-threshold
Don't keep more than this much size of undo information.
A command which pushes past this size is itself forgotten.
This threshold is applied when garbage collection happens.
The size is counted as the number of bytes occupied,
which includes both saved text and other data.V gc-currently-forbidden
internal variable used to control undoFbuffer-list
Return a list of all existing live buffers.
The order is specific to the selected screen; if the optional SCREEN
argument is provided, the ordering for that screen is returned instead.
If the SCREEN argument is t, then the global (non-screen) ordering is
returned instead.
arguments:(&optional screen)
Fget-buffer
Return the buffer named NAME (a string).
If there is no live buffer named NAME, return nil.
NAME may also be a buffer; if so, the value is that buffer.
arguments:(name)
Fget-file-buffer
Return the buffer visiting file FILENAME (a string).
If there is no such live buffer, return nil.
arguments:(filename)
Fget-buffer-create
Return the buffer named NAME, or create such a buffer and return it.
A new buffer is created if there is no live buffer named NAME.
If NAME starts with a space, the new buffer does not keep undo information.
If NAME is a buffer instead of a string, then it is the value returned.
The value is never nil.
arguments:(name)
Fgenerate-new-buffer-name
Return a string that is the name of no existing buffer based on NAME.
If there is no live buffer named NAME, then return NAME.
Otherwise modify name by appending `<NUMBER>', incrementing NUMBER
until an unused name is found, and then return that name.
arguments:(name)
Fbuffer-name
Return the name of BUFFER, as a string.
With no argument or nil as argument, return the name of the current buffer.
arguments:(&optional buffer)
Fbuffer-file-name
Return name of file BUFFER is visiting, or nil if none.
No argument or nil as argument means use the current buffer.
arguments:(&optional buffer)
Fbuffer-local-variables
Return an alist of variables that are buffer-local in BUFFER.
Each element looks like (SYMBOL . VALUE) and describes one variable.
Note that storing new VALUEs in these elements doesn't change the variables.
No argument or nil as argument means use current buffer as BUFFER.
arguments:(&optional buffer)
Fbuffer-dedicated-screen
Return the screen dedicated to this BUFFER, or nil if there is none.
No argument or nil as argument means use current buffer as BUFFER.
arguments:(&optional buffer)
Fset-buffer-dedicated-screen
For this BUFFER, set the SCREEN dedicated to it.
SCREEN must be a screen or nil.
arguments:(buffer screen)
Fbuffer-modified-p
Return t if BUFFER was modified since its file was last read or saved.
No argument or nil as argument means use current buffer as BUFFER.
arguments:(&optional buffer)
Fset-buffer-modified-p
Mark current buffer as modified or unmodified according to FLAG.
A non-nil FLAG means mark the buffer modified.
arguments:(flag)
Fbuffer-modified-tick
Return BUFFER's tick counter, incremented for each change in text.
Each buffer has a tick counter which is incremented each time the text in
that buffer is changed. It wraps around occasionally.
No argument or nil as argument means use current buffer as BUFFER.
arguments:(&optional buffer)
Frename-buffer
Change current buffer's name to NEWNAME (a string).
If second arg DISTINGUISH is nil or omitted, it is an error if a
buffer named NEWNAME already exists.
If DISTINGUISH is non-nil, come up with a new name using
`generate-new-buffer-name'.
Return the name we actually gave the buffer.
This does not change the name of the visited file (if any).
arguments:(name &optional distinguish)
Fother-buffer
Return most recently selected buffer other than BUFFER.
Buffers not visible in windows are preferred to visible buffers.
If no other buffer exists, the buffer `*scratch*' is returned.
If BUFFER is omitted or nil, some interesting buffer is returned.
The ordering is for this screen; If second optional argument SCREEN
is provided, then the ordering is for that screen. If the second arg
is t, then the global ordering is returned.
arguments:(&optional buffer screen)
Fbuffer-disable-undo
Make BUFFER stop keeping undo information.
Any undo records it already has are discarded.
arguments:(buffer)
Fbuffer-enable-undo
Start keeping undo information for buffer BUFFER.
No argument or nil as argument means do this for the current buffer.
arguments:(&optional buffer)
Fkill-buffer
Kill the buffer BUFFER.
The argument may be a buffer or may be the name of a buffer.
An argument of nil means kill the current buffer.
Value is t if the buffer is actually killed, nil if user says no.
The value of `kill-buffer-hook' (which may be local to that buffer),
if not void, is a list of functions to be called, with no arguments,
before the buffer is actually killed. The buffer to be killed is current
when the hook functions are called.
Any processes that have this buffer as the `process-buffer' are killed
with `delete-process'.
arguments:(bufname)
Fswitch-to-buffer
Select buffer BUFFER in the current window.
BUFFER may be a buffer or a buffer name.
Optional second arg NORECORD non-nil means
do not put this buffer at the front of the list of recently selected ones.
WARNING: This is NOT the way to work on another buffer temporarily
within a Lisp program! Use `set-buffer' instead. That avoids messing with
the window-buffer correspondences.
arguments:(bufname &optional norecord)
Fpop-to-buffer
Select buffer BUFFER in some window, preferably a different one.
If BUFFER is nil, then some other buffer is chosen.
If `pop-up-windows' is non-nil, windows can be split to do this.
If optional second arg WINDOW is non-nil, insist on finding another
window even if BUFFER is already visible in the selected window.
If optional third arg is non-nil, it is the screen to pop to this
buffer on.
arguments:(bufname &optional not_this_window_p on_screen)
Fcurrent-buffer
Return the current buffer as a Lisp object.
arguments:()
Fset-buffer
Make the buffer BUFFER current for editing operations.
BUFFER may be a buffer or the name of an existing buffer.
See also `save-excursion' when you want to make a buffer current temporarily.
This function does not display the buffer, so its effect ends
when the current command terminates.
Use `switch-to-buffer' or `pop-to-buffer' to switch buffers permanently.
arguments:(bufname)
Fbarf-if-buffer-read-only
Signal a `buffer-read-only' error if the current buffer is read-only.
arguments:()
Fbury-buffer
Put BUFFER at the end of the list of all buffers.
There it is the least likely candidate for `other-buffer' to return;
thus, the least likely buffer for \[switch-to-buffer] to select by default.
arguments:(&optional buffer)
Ferase-buffer
Delete the entire contents of the current buffer.
Any clipping restriction in effect (see `narrow-to-buffer') is removed,
so the buffer is truly empty after this.
arguments:()
Fkill-all-local-variables
Switch to Fundamental mode by killing current buffer's local variables.
Most local variable bindings are eliminated so that the default values
become effective once more. Also, the syntax table is set from
`standard-syntax-table', the local keymap is set to nil,
and the abbrev table from `fundamental-mode-abbrev-table'.
This function also forces redisplay of the mode line.
Every function to select a new major mode starts by
calling this function.
As a special exception, local variables whose names have
a non-nil `permanent-local' property are not eliminated by this function.
arguments:()
Fregion-fields
Return list of fields overlapping a given portion of a buffer.
The portion is specified by arguments START, END and BUFFER.
BUFFER defaults to the current buffer.
Optional 4th arg ERROR-CHECK non nil means just report an error
if any protected fields overlap this portion.
arguments:(start end &optional buffer error_check)
Vdefault-mode-line-format
Default value of `mode-line-format' for buffers that don't override it.
This is the same as (default-value 'mode-line-format).Vdefault-abbrev-mode
Default value of `abbrev-mode' for buffers that do not override it.
This is the same as (default-value 'abbrev-mode).Vdefault-ctl-arrow
Default value of `ctl-arrow' for buffers that do not override it.
This is the same as (default-value 'ctl-arrow).Vdefault-truncate-lines
Default value of `truncate-lines' for buffers that do not override it.
This is the same as (default-value 'truncate-lines).Vdefault-fill-column
Default value of `fill-column' for buffers that do not override it.
This is the same as (default-value 'fill-column).Vdefault-left-margin
Default value of `left-margin' for buffers that do not override it.
This is the same as (default-value 'left-margin).Vdefault-tab-width
Default value of `tab-width' for buffers that do not override it.
This is the same as (default-value 'tab-width).Vdefault-case-fold-search
Default value of `case-fold-search' for buffers that don't override it.
This is the same as (default-value 'case-fold-search).Vdefault-file-type
Default value of `file-type' for buffers that do not override it.
This is the same as (default-value 'file-type).Vmode-line-format
Template for displaying mode line for current buffer.
Each buffer has its own value of this variable.
Value may be a string, a symbol or a list or cons cell.
For a symbol, its value is used (but it is ignored if t or nil).
A string appearing directly as the value of a symbol is processed verbatim
in that the %-constructs below are not recognized.
For a list whose car is a symbol, the symbol's value is taken,
and if that is non-nil, the cadr of the list is processed recursively.
Otherwise, the caddr of the list (if there is one) is processed.
For a list whose car is a string or list, each element is processed
recursively and the results are effectively concatenated.
For a list whose car is an integer, the cdr of the list is processed
and padded (if the number is positive) or truncated (if negative)
to the width specified by that number.
A string is printed verbatim in the mode line except for %-constructs:
(%-constructs are allowed when the string is the entire mode-line-format
or when it is found in a cons-cell or a list)
%b -- print buffer name. %f -- print visited file name.
%* -- print *, % or hyphen. %m -- print value of mode-name (obsolete).
%s -- print process status. %M -- print value of global-mode-string. (obs)
%S -- print name of selected screen (only meaningful under X Windows).
%p -- print percent of buffer above top of window, or top, bot or all.
%n -- print Narrow if appropriate.
%[ -- print one [ for each recursive editing level. %] similar.
%% -- print %. %- -- print infinitely many dashes.
Decimal digits after the % specify field width to which to pad.Vdefault-major-mode
*Major mode for new buffers. Defaults to `fundamental-mode'.
nil here means use current buffer's major mode.Vmajor-mode
Symbol for current buffer's major mode.Vmode-name
Pretty name of current buffer's major mode (a string).Vabbrev-mode
Non-nil turns on automatic expansion of abbrevs as they are inserted.
Automatically becomes buffer-local when set in any fashion.Vcase-fold-search
*Non-nil if searches should ignore case.
Automatically becomes buffer-local when set in any fashion.Vfill-column
*Column beyond which automatic line-wrapping should happen.
Automatically becomes buffer-local when set in any fashion.Vleft-margin
*Column for the default indent-line-function to indent to.
Linefeed indents to this column in Fundamental mode.
Automatically becomes buffer-local when set in any fashion.Vtab-width
*Distance between tab stops (for display of tab characters), in columns.
Automatically becomes buffer-local when set in any fashion.Vctl-arrow
*Non-nil means display control chars with uparrow.
Nil means use backslash and octal digits.
An integer means characters >= ctl-arrow are assumed to be printable, and
will be displayed as a single glyph.
Any other value is the same as 160 - the code SPC with the high bit on.
The interpretation of this variable is likely to change in the future.
Automatically becomes buffer-local when set in any fashion.
This variable does not apply to characters whose display is specified
in the current display table (if there is one).Vtruncate-lines
*Non-nil means do not display continuation lines;
give each line of text one screen line.
Automatically becomes buffer-local when set in any fashion.
Note that this is overridden by the variable
`truncate-partial-width-windows' if that variable is non-nil
and this buffer is not full-screen width.Vfile-type
*file-type for file and process input/output.Vdefault-directory
Name of default directory of current buffer. Should end with slash.
Each buffer has its own value of this variable.Vauto-fill-function
Function called (if non-nil) to perform auto-fill.
It is called after self-inserting a space at a column beyond `fill-column'.
Each buffer has its own value of this variable.
NOTE: This variable is not an ordinary hook;
It may not be a list of functions.Vbuffer-file-name
Name of file visited in current buffer, or nil if not visiting a file.
Each buffer has its own value of this variable.Vbuffer-file-truename
The real name of the file visited in the current buffer,
or nil if not visiting a file. This is the result of passing
buffer-file-name to the real-path-name function. Every buffer
has its own value of this variable. This variable is automatically
maintained by the functions that change the file name associated
with a buffer.Vbuffer-auto-save-file-name
Name of file for auto-saving current buffer,
or nil if buffer should not be auto-saved.
Each buffer has its own value of this variable.Vbuffer-read-only
Non-nil if this buffer is read-only.
Each buffer has its own value of this variable.Vbuffer-backed-up
Non-nil if this buffer's file has been backed up.
Backing up is done before the first time the file is saved.
Each buffer has its own value of this variable.Vbuffer-saved-size
Length of current buffer when last read in, saved or auto-saved.
0 initially.
Each buffer has its own value of this variable.Vselective-display
Non-nil enables selective display:
Integer N as value means display only lines
that start with less than n columns of space.
A value of t means, after a ^M, all the rest of the line is invisible.
Then ^M's in the file are written into files as newlines.
Automatically becomes buffer-local when set in any fashion.Vlocal-abbrev-table
Local (mode-specific) abbrev table of current buffer.Vselective-display-ellipses
t means display ... on previous line when a line is invisible.
Automatically becomes buffer-local when set in any fashion.Voverwrite-mode
Non-nil if self-insertion should replace existing text.
Automatically becomes buffer-local when set in any fashion.Vbuffer-display-table
Display table that controls display of the contents of current buffer.
Automatically becomes buffer-local when set in any fashion.
The display table is a vector created with `make-display-table'.
The first 256 elements control how to display each possible text character.
The value should be a "rope" (see `make-rope') or nil;
nil means display the character in the default fashion.
The remaining five elements are ropes that control the display of
the end of a truncated screen line (element 256);
the end of a continued line (element 257);
the escape character used to display character codes in octal (element 258);
the character used as an arrow for control characters (element 259);
the decoration indicating the presence of invisible lines (element 260).
If this variable is nil, the value of `standard-display-table' is used.
Each window can have its own, overriding display table.Vbuffer-field-list
List of fields in the current buffer. See `add-field'.Vfind-file-compare-truenames
If this is true, then the find-file command will check the truenames
of all visited files when deciding whether a given file is already in
a buffer, instead of just the buffer-file-name. This means that if you
attempt to visit another file which is a hard-link or symbolic-link to a
file which is already in a buffer, the existing buffer will be found instead
of a newly-created one.
See also the variable find-file-use-truenames.Vfind-file-use-truenames
If this is true, then a buffer's visited file-name will always be
chased back to the real file; it will never be a symbolic link, and there
will never be a symbolic link anywhere in its directory path.
That is, the buffer-file-name and buffer-file-truename will be equal.
See also the variable find-file-compare-truenames.Vbefore-change-function
Function to call before each text change.
Two arguments are passed to the function: the positions of
the beginning and end of the range of old text to be changed.
For an insertion, the beginning and end are at the same place.
No information is given about the length of the text after the change.
position of the change
While executing the `before-change-function', changes to buffers do not
cause calls to any `before-change-function' or `after-change-function'.Vafter-change-function
Function to call after each text change.
Three arguments are passed to the function: the positions of
the beginning and end of the range of changed text,
and the length of the pre-change text replaced by that range.
For an insertion, the pre-change length is zero;
for a deletion, that length is the number of characters deleted,
and the post-change beginning and end are at the same place.
While executing the `after-change-function', changes to buffers do not
cause calls to any `before-change-function' or `after-change-function'.Vfirst-change-function
Function to call before changing a buffer which is unmodified.
The function is called, with no arguments, if it is non-nil.Vbuffer-undo-list
List of undo entries in current buffer.Fbyte-code
Function used internally in byte-compiled code.
The first argument is a string of byte code; the second, a vector of constants;
the third, the maximum stack depth used in this function.
If the third argument is incorrect, Emacs may crash.
arguments:(bytestr vector maxdepth)
Vbyte-code-meter
A vector of vectors which holds a histogram of byte-code usage.Vbyte-metering-on
Finteractive
Specify a way of parsing arguments for interactive use of a function.
For example, write
(defun foo (arg) "Doc string" (interactive "p") ...use arg...)
to make ARG be the prefix argument when `foo' is called as a command.
The "call" to `interactive' is actually a declaration rather than a function;
it tells `call-interactively' how to read arguments
to pass to the function.
When actually called, `interactive' just returns nil.
The argument of `interactive' is usually a string containing a code letter
followed by a prompt. (Some code letters do not use I/O to get
the argument and do not need prompts.) To prompt for multiple arguments,
give a code letter, its prompt, a newline, and another code letter, etc.
Prompts are passed to format, and may use % escapes to print the
arguments that have already been read.
If the argument is not a string, it is evaluated to get a list of
arguments to pass to the function.
Just `(interactive)' means pass no args when calling interactively.
Code letters available are:
a -- Function name: symbol with a function definition.
b -- Name of existing buffer.
B -- Name of buffer, possibly nonexistent.
c -- Character.
C -- Command name: symbol with interactive function definition.
d -- Value of point as number. Does not do I/O.
D -- Directory name.
e -- Last mouse event.
f -- Existing file name.
F -- Possibly nonexistent file name.
k -- Key sequence (a vector of events).
m -- Value of mark as number. Does not do I/O.
n -- Number read using minibuffer.
N -- Prefix arg converted to number, or if none, do like code `n'.
p -- Prefix arg converted to number. Does not do I/O.
P -- Prefix arg in raw form. Does not do I/O.
r -- Region: point and mark as 2 numeric args, smallest first. Does no I/O.
s -- Any string.
S -- Any symbol.
v -- Variable name: symbol that is user-variable-p.
x -- Lisp expression read but not evaluated.
X -- Lisp expression read and evaluated.
In addition, if the string begins with `*'
then an error is signaled if the buffer is read-only.
This happens before reading any arguments.
If the string begins with `@', then the window the mouse is over is selected
before anything else is done. You may use both `@' and `*';
they are processed in the order that they appear.
arguments:(args)
Fcall-interactively
Call FUNCTION, reading args according to its interactive calling specs.
The function contains a specification of how to do the argument reading.
In the case of user-defined functions, this is specified by placing a call
to the function `interactive' at the top level of the function body.
See `interactive'.
If optional second arg RECORD-FLAG is `t' then unconditionally put this
ommand in the command-history. Otherwise, this is done only if an arg is
read using the minibuffer.
arguments:(function &optional record_flag)
Fprefix-numeric-value
Return numeric meaning of raw prefix argument ARG.
A raw prefix argument is what you get from `(interactive "P")'.
Its numeric meaning is what you would get from `(interactive "p")'.
arguments:(raw)
Vprefix-arg
The value of the prefix argument for the next editing command.
It may be a number, or the symbol `-' for just a minus sign as arg,
or a list whose car is a number for just one or more C-U's
or nil if no argument has been specified.
You cannot examine this variable to find the argument for this command
since it has been set to nil by the time you can look.
Instead, you should use the variable `current-prefix-arg', although
normally commands can get this prefix argument with (interactive "P").Vcurrent-prefix-arg
The value of the prefix argument for this editing command.
It may be a number, or the symbol `-' for just a minus sign as arg,
or a list whose car is a number for just one or more C-U's
or nil if no argument has been specified.
This is what `(interactive "P")' returns.Vcurrent-mouse-event
The mouse-button event which invoked this command, or nil.
This is what `(interactive "e")' returns.Vcommand-history
List of recent commands that read arguments from terminal.
Each command is represented as a form to evaluate.Vcommand-debug-status
Debugging status of current interactive command.
Bound each time `call-interactively' is called;
may be set by the debugger as a reminder for itself.Fcall-process
Call PROGRAM synchronously in separate process.
The program's input comes from file INFILE (nil means `/dev/null').
Insert output in BUFFER before point; t means current buffer;
nil for BUFFER means discard it; 0 means discard and don't wait.
Fourth arg DISPLAY non-nil means redisplay buffer as output is inserted.
Remaining arguments are strings passed as command arguments to PROGRAM.
If BUFFER is nil or 0, returns immediately with value nil.
Otherwise waits for PROGRAM to terminate
and returns a numeric exit status or a signal name as a string.
If you quit, the process is killed with SIGKILL.
arguments: (arg1 &rest args)
Fcall-process-region
Send text from START to END to a synchronous process running PROGRAM.
Delete the text if fourth arg DELETE is non-nil.
Insert output in BUFFER before point; t means current buffer;
nil for BUFFER means discard it; 0 means discard and don't wait.
Sixth arg DISPLAY non-nil means redisplay buffer as output is inserted.
Remaining args are passed to PROGRAM at startup as command args.
If BUFFER is nil, returns immediately with value nil.
Otherwise waits for PROGRAM to terminate
and returns a numeric exit status or a signal name as a string.
If you quit, the process is killed with SIGKILL.
arguments: (arg1 arg2 arg3 &rest args)
Vshell-file-name
*File name to load inferior shells from.
Initialized from the SHELL environment variable.Vexec-path
*List of directories to search programs to run in subprocesses.
Each element is a string (directory name) or nil (try default directory).Vexec-directory
Directory that holds programs that come with GNU Emacs,
intended for Emacs to invoke.Vprocess-environment
List of strings to append to environment of subprocesses that are started.
Each string should have the format ENVVARNAME=VALUE.Fupcase
Convert argument to upper case and return that.
The argument may be a character or string. The result has the same type.
The argument object is not altered. See also `capitalize'.
arguments:(obj)
Fdowncase
Convert argument to lower case and return that.
The argument may be a character or string. The result has the same type.
The argument object is not altered.
arguments:(obj)
Fcapitalize
Convert argument to capitalized form and return that.
This means that each word's first character is upper case
and the rest is lower case.
The argument may be a character or string. The result has the same type.
The argument object is not altered.
arguments:(obj)
Fupcase-region
Convert the region to upper case. In programs, wants two arguments.
These arguments specify the starting and ending character numbers of
the region to operate on. When used as a command, the text between
point and the mark is operated on.
See also `capitalize-region'.
arguments:(b e)
Fdowncase-region
Convert the region to lower case. In programs, wants two arguments.
These arguments specify the starting and ending character numbers of
the region to operate on. When used as a command, the text between
point and the mark is operated on.
arguments:(b e)
Fcapitalize-region
Convert the region to capitalized form.
Capitalized form means each word's first character is upper case
and the rest of it is lower case.
In programs, give two arguments, the starting and ending
character positions to operate on.
arguments:(b e)
Fupcase-word
Convert following word (or ARG words) to upper case, moving over.
With negative argument, convert previous words but do not move.
See also `capitalize-word'.
arguments:(arg)
Fdowncase-word
Convert following word (or ARG words) to lower case, moving over.
With negative argument, convert previous words but do not move.
arguments:(arg)
Fcapitalize-word
Capitalize the following word (or ARG words), moving over.
This gives the word(s) a first character in upper case
and the rest lower case.
With negative argument, capitalize previous words but do not move.
arguments:(arg)
Fcase-table-p
Return t iff ARG is a case table.
See `set-case-table' for more information on these data structures.
arguments:(table)
Fcurrent-case-table
Return the case table of the current buffer.
arguments:()
Fstandard-case-table
Return the standard case table.
This is the one used for new buffers.
arguments:()
Fset-case-table
Select a new case table for the current buffer.
A case table is a list (DOWNCASE UPCASE CANONICALIZE EQUIVALENCES)
where each element is either nil or a string of length 256.
DOWNCASE maps each character to its lower-case equivalent.
UPCASE maps each character to its upper-case equivalent;
if lower and upper case characters are in 1-1 correspondence,
you may use nil and the upcase table will be deduced from DOWNCASE.
CANONICALIZE maps each character to a canonical equivalent;
any two characters that are related by case-conversion have the same
canonical equivalent character.
EQUIVALENCES is a map that cyclicly permutes each equivalence class
(of characters with the same canonical equivalent).
Both CANONICALIZE and EQUIVALENCES may be nil, in which case
both are deduced from DOWNCASE and UPCASE.
arguments:(table)
Fset-standard-case-table
Select a new standard case table for new buffers.
See `set-case-table' for more info on case tables.
arguments:(table)
Vascii-downcase-table
String mapping ASCII characters to lowercase equivalents.Vascii-upcase-table
String mapping ASCII characters to uppercase equivalents.Fforward-char
Move point right ARG characters (left if ARG negative).
On reaching end of buffer, stop and signal error.
arguments:(&optional n)
Fbackward-char
Move point left ARG characters (right if ARG negative).
On attempt to pass beginning or end of buffer, stop and signal error.
arguments:(&optional n)
Fforward-line
Move ARG lines forward (backward if ARG is negative).
Precisely, if point is on line I, move to the start of line I + ARG.
If there isn't room, go as far as possible (no error).
Returns the count of lines left to move. If moving forward,
that is ARG - number of lines moved; if backward, ARG + number moved.
With positive ARG, a non-empty line at the end counts as one line
successfully moved (for the return value).
arguments:(&optional n)
Fbeginning-of-line
Move point to beginning of current line.
With argument ARG not nil or 1, move forward ARG - 1 lines first.
If scan reaches end of buffer, stop there without error.
arguments:(&optional n)
Fend-of-line
Move point to end of current line.
With argument ARG not nil or 1, move forward ARG - 1 lines first.
If scan reaches end of buffer, stop there without error.
arguments:(&optional n)
Fdelete-char
Delete the following ARG characters (previous, with negative arg).
Optional second arg KILLFLAG non-nil means kill instead (save in kill ring).
Interactively, ARG is the prefix arg, and KILLFLAG is set if
ARG was explicitly specified.
arguments:(n &optional killflag)
Fdelete-backward-char
Delete the previous ARG characters (following, with negative ARG).
Optional second arg KILLFLAG non-nil means kill instead (save in kill ring).
Interactively, ARG is the prefix arg, and KILLFLAG is set if
ARG was explicitly specified.
arguments:(n &optional killflag)
Fself-insert-command
Insert the character you type.
Whichever character you type to run this command is inserted.
arguments:(arg)
Fnewline
Insert a newline. With arg, insert that many newlines.
In Auto Fill mode, if no numeric arg, break the preceding line if it's long.
arguments:(&optional arg1)
Vblink-paren-function
Function called, if non-nil, whenever a close parenthesis is inserted.
More precisely, a char with closeparen syntax is self-inserted.Feq
T if the two args are the same Lisp object.
arguments:(obj1 obj2)
Fnull
T if OBJECT is nil.
arguments:(obj)
Fconsp
T if OBJECT is a cons cell.
arguments:(obj)
Fatom
T if OBJECT is not a cons cell. This includes nil.
arguments:(obj)
Flistp
T if OBJECT is a list. This includes nil.
arguments:(obj)
Fnlistp
T if OBJECT is not a list. Lists include nil.
arguments:(obj)
Fsymbolp
T if OBJECT is a symbol.
arguments:(obj)
Fvectorp
T if OBJECT is a vector.
arguments:(obj)
Fstringp
T if OBJECT is a string.
arguments:(obj)
Farrayp
T if OBJECT is an array (string or vector).
arguments:(obj)
Fsequencep
T if OBJECT is a sequence (list or array).
arguments:(obj)
Fbufferp
T if OBJECT is an editor buffer.
arguments:(obj)
Fmarkerp
T if OBJECT is a marker (editor pointer).
arguments:(obj)
Finteger-or-marker-p
T if OBJECT is an integer or a marker (editor pointer).
arguments:(obj)
Fsubrp
T if OBJECT is a built-in function.
arguments:(obj)
Fcompiled-function-p
T if OBJECT is a compiled function object (as returned by make-byte-code.)
arguments:(obj)
Fchar-or-string-p
T if OBJECT is a character (a number) or a string.
arguments:(obj)
Fintegerp
T if OBJECT is a number.
arguments:(obj)
Fnatnump
T if OBJECT is a nonnegative number.
arguments:(obj)
Ffloatp
T if OBJECT is a floating point number.
arguments:(obj)
Fnumberp
T if OBJECT is a number (floating point or integer).
arguments:(obj)
Fnumber-or-marker-p
T if OBJECT is a number or a marker.
arguments:(obj)
Fextentp
T if OBJECT is an extent..
arguments:(extent)
Fcar
Return the car of CONSCELL. If arg is nil, return nil.
Error if arg is not nil and not a cons cell. See also `car-safe'.
arguments:(list)
Fcar-safe
Return the car of OBJECT if it is a cons cell, or else nil.
arguments:(object)
Fcdr
Return the cdr of CONSCELL. If arg is nil, return nil.
Error if arg is not nil and not a cons cell. See also `cdr-safe'.
arguments:(list)
Fcdr-safe
Return the cdr of OBJECT if it is a cons cell, or else nil.
arguments:(object)
Fsetcar
Set the car of CONSCELL to be NEWCAR. Returns NEWCAR.
arguments:(cell newcar)
Fsetcdr
Set the cdr of CONSCELL to be NEWCDR. Returns NEWCDR.
arguments:(cell newcdr)
Fboundp
T if SYMBOL's value is not void.
arguments:(sym)
Ffboundp
T if SYMBOL's function definition is not void.
arguments:(sym)
Fmakunbound
Make SYMBOL's value be void.
arguments:(sym)
Ffmakunbound
Make SYMBOL's function definition be void.
arguments:(sym)
Fsymbol-function
Return SYMBOL's function definition. Error if that is void.
arguments:(sym)
Fsymbol-plist
Return SYMBOL's property list.
arguments:(sym)
Fsymbol-name
Return SYMBOL's name, a string.
arguments:(sym)
Ffset
Set SYMBOL's function definition to NEWVAL, and return NEWVAL.
arguments:(sym newdef)
Fsetplist
Set SYMBOL's property list to NEWVAL, and return NEWVAL.
arguments:(sym newplist)
Fsymbol-value
Return SYMBOL's value. Error if that is void.
arguments:(sym)
Fset
Set SYMBOL's value to NEWVAL, and return NEWVAL.
arguments:(sym newval)
Fdefault-boundp
Return T if SYMBOL has a non-void default value.
This is the value that is seen in buffers that do not have their own values
for this variable.
arguments:(sym)
Fdefault-value
Return SYMBOL's default value.
This is the value that is seen in buffers that do not have their own values
for this variable. The default value is meaningful for variables with
local bindings in certain buffers.
arguments:(sym)
Fset-default
Set SYMBOL's default value to VAL. SYMBOL and VAL are evaluated.
The default value is seen in buffers that do not have their own values
for this variable.
arguments:(sym value)
Fsetq-default
Set SYMBOL's default value to VAL. VAL is evaluated; SYMBOL is not.
The default value is seen in buffers that do not have their own values
for this variable.
arguments: (arg1 arg2 &rest args)
Fmake-variable-buffer-local
Make VARIABLE have a separate value for each buffer.
At any time, the value for the current buffer is in effect.
There is also a default value which is seen in any buffer which has not yet
set its own value.
Using `set' or `setq' to set the variable causes it to have a separate value
for the current buffer if it was previously using the default value.
The function `default-value' gets the default value and `set-default' sets it.
arguments:(sym)
Fmake-local-variable
Make VARIABLE have a separate value in the current buffer.
Other buffers will continue to share a common default value.
See also `make-variable-buffer-local'.
arguments:(sym)
Fkill-local-variable
Make VARIABLE no longer have a separate value in the current buffer.
From now on the default value will apply in this buffer.
arguments:(sym)
Findirect-function
Return the function at the end of OBJECT's function chain.
If OBJECT is a symbol, follow all function indirections and return
the final function binding.
If OBJECT is not a symbol, just return it.
Signal a void-function error if the final symbol is unbound.
Signal a cyclic-function-indirection error if there is a loop in the
function chain of symbols.
arguments:(object)
Faref
Return the element of ARRAY at index INDEX.
ARRAY may be a vector or a string, or a byte-code object. INDEX starts at 0.
arguments:(array idx)
Faset
Store into the element of ARRAY at index INDEX the value NEWVAL.
ARRAY may be a vector or a string. INDEX starts at 0.
arguments:(array idx newelt)
F=
T if two args, both numbers or markers, are equal.
arguments:(num1 num2)
F<
T if first arg is less than second arg. Both must be numbers or markers.
arguments:(num1 num2)
F>
T if first arg is greater than second arg. Both must be numbers or markers.
arguments:(num1 num2)
F<=
T if first arg is less than or equal to second arg.
Both must be numbers or markers.
arguments:(num1 num2)
F>=
T if first arg is greater than or equal to second arg.
Both must be numbers or markers.
arguments:(num1 num2)
F/=
T if first arg is not equal to second arg. Both must be numbers or markers.
arguments:(num1 num2)
Fzerop
T if NUMBER is zero.
arguments:(num)
Fint-to-string
Convert INT to a string by printing it in decimal.
Uses a minus sign if negative.
arguments:(num)
Fstring-to-int
Convert STRING to an integer by parsing it as a decimal number.
arguments:(str)
F+
Return sum of any number of arguments, which are numbers or markers.
arguments: (&rest args)
F-
Negate number or subtract numbers or markers.
With one arg, negates it. With more than one arg,
subtracts all but the first from the first.
arguments: (&rest args)
F*
Returns product of any number of arguments, which are numbers or markers.
arguments: (&rest args)
F/
Returns first argument divided by all the remaining arguments.
The arguments must be numbers or markers.
arguments: (arg1 arg2 &rest args)
F%
Returns remainder of first arg divided by second.
Both must be numbers or markers.
arguments:(num1 num2)
Fmax
Return largest of all the arguments (which must be numbers or markers).
The value is always a number; markers are converted to numbers.
arguments: (arg1 &rest args)
Fmin
Return smallest of all the arguments (which must be numbers or markers).
The value is always a number; markers are converted to numbers.
arguments: (arg1 &rest args)
Flogand
Return bitwise-and of all the arguments.
Arguments may be integers, or markers converted to integers.
arguments: (&rest args)
Flogior
Return bitwise-or of all the arguments.
Arguments may be integers, or markers converted to integers.
arguments: (&rest args)
Flogxor
Return bitwise-exclusive-or of all the arguments.
Arguments may be integers, or markers converted to integers.
arguments: (&rest args)
Fash
Return VALUE with its bits shifted left by COUNT.
If COUNT is negative, shifting is actually to the right.
In this case, the sign bit is duplicated.
arguments:(num1 num2)
Flsh
Return VALUE with its bits shifted left by COUNT.
If COUNT is negative, shifting is actually to the right.
In this case, zeros are shifted in on the left.
arguments:(num1 num2)
F1+
Return NUMBER plus one. NUMBER may be a number or a marker.
Markers are converted to integers.
arguments:(num)
F1-
Return NUMBER minus one. NUMBER may be a number or a marker.
Markers are converted to integers.
arguments:(num)
Flognot
Return the bitwise complement of ARG. ARG must be an integer.
arguments:(num)
Fdirectory-files
Return a list of names of files in DIRECTORY.
There are four optional arguments:
If FULL is non-nil, absolute pathnames of the files are returned.
If MATCH is non-nil, only pathnames containing that regexp are returned.
If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
NOSORT is useful if you plan to sort the result yourself.
If FILES-ONLY is the symbol t, then only the "files" in the directory
will be returned; subdirectories will be excluded. If FILES-ONLY is not
nil and not t, then only the subdirectories will be returned. Otherwise,
if FILES-ONLY is nil (the default) then both files and subdirectories will
be returned.
arguments:(dirname &optional full match nosort files_only)
Ffile-name-completion
Complete file name FILE in directory DIR.
Returns the longest string
common to all filenames in DIR that start with FILE.
If there is only one and FILE matches it exactly, returns t.
Returns nil if DIR contains no name starting with FILE.
arguments:(file dirname)
Ffile-name-all-completions
Return a list of all completions of file name FILE in directory DIR.
These are all file names in directory DIR which begin with FILE.
arguments:(file dirname)
Ffile-name-all-versions
Return a list of all versions of file name FILE in directory DIR.
arguments:(file dirname)
Ffile-attributes
Return a list of attributes of file FILENAME.
Value is nil if specified file cannot be opened.
Otherwise, list elements are:
0. t for directory, string (name linked to) for symbolic link, or nil.
1. Number of links to file.
2. File uid.
3. File gid.
4. Last access time, as a list of two integers.
First integer has high-order 16 bits of time, second has low 16 bits.
5. Last modification time, likewise.
6. Last status change time, likewise.
7. Size in bytes.
8. File modes, as a string of ten letters or dashes as in ls -l.
9. t iff file's gid would change if file were deleted and recreated.
10. inode number.
If file does not exists, returns nil.
arguments:(filename)
Ftime-to-string
arguments:(time)
Vcompletion-ignored-extensions
*Completion ignores filenames ending in any string in this list.
This variable does not affect lists of possible completions,
but does affect the commands that actually do completions.Fopen-termscript
Start writing all terminal output to FILE as well as the terminal.
FILE = nil means just close any termscript file currently open.
arguments:(file)
Fsend-string-to-terminal
Send STRING to the terminal without alteration.
Control characters in STRING will have terminal-dependent effects.
arguments:(str)
Fding
Beep, or flash the screen.
Also, unless an argument is given,
terminate any keyboard macro currently executing.
When called from lisp, the second argument is what sound to make.
arguments:(&optional arg sound)
Finitialize-first-screen
Make redisplay work on the first screen (do this early.)
arguments:()
Vbaud-rate
The output baud rate of the terminal.
On most systems, changing this value will affect the amount of padding
and the other strategic decisions made during redisplay.Vinverse-video
*Non-nil means invert the entire screen display.
This means everything is in inverse video which otherwise would not be.Vvisible-bell
*Non-nil means try to flash the screen to represent a bell.Vno-redraw-on-reenter
*Non-nil means no need to redraw entire screen after suspending.
A non-nil value is useful if the terminal can automatically preserve
Emacs's screen display when you reenter Emacs.
It is up to you to set this variable if your terminal can do that.Vwindow-system
A symbol naming the window-system under which Emacs is running,
such as `x', or nil if emacs is running on an ordinary terminal.Vwindow-system-version
The version number of the window system in use.
For X windows, this is 10 or 11.Vcursor-in-echo-area
Non-nil means put cursor in minibuffer, at end of any message there.Vglyph-table
Table defining how to output a glyph code to the screen.
If not nil, this is a vector indexed by glyph code to define the glyph.
Each element can be:
integer: a glyph code which this glyph is an alias for.
string: output this glyph using that string (not impl. in X windows).
nil: this glyph mod 256 is char code to output,
and this glyph / 256 is face code for X windows (see `x-set-face').Vstandard-display-table
Display table to use for buffers that specify none.
See `buffer-display-table' for more information.Fdocumentation
Return the documentation string of FUNCTION.
arguments:(fun1)
Fdocumentation-property
Return the documentation string that is SYMBOL's PROP property.
This differs from using `get' only in that it can refer to strings
stored in the `etc/DOC' file.
arguments:(sym prop)
FSnarf-documentation
Used during Emacs initialization, before dumping runnable Emacs,
to find pointers to doc strings stored in `etc/DOC...' and
record them in function definitions.
One arg, FILENAME, a string which does not include a directory.
The file is found in `../etc' now; found in the `exec-directory'
when doc strings are referred to later in the dumped Emacs.
arguments:(filename)
FVerify-documentation
Used to make sure everything went well with Snarf-documentation.
Writes to stderr if not.
arguments:()
Fsubstitute-command-keys
Substitute key descriptions for command names in STRING.
Return a new string which is STRING with substrings of the form \=\[COMMAND]
replaced by either: a keystroke sequence that will invoke COMMAND,
or "M-x COMMAND" if COMMAND is not on any keys.
Substrings of the form \=\{MAPVAR} are replaced by summaries
(made by describe-bindings) of the value of MAPVAR, taken as a keymap.
Substrings of the form \=\<MAPVAR> specify to use the value of MAPVAR
as the keymap for future \=\[COMMAND] substrings.
\=\= quotes the following character and is discarded;
thus, \=\=\=\= puts \=\= into the output, and \=\=\=\[ puts \=\[ into the output.
arguments:(str)
Vinternal-doc-file-name
Name of file containing documentation strings of built-in symbols.Fint86
arguments:(intno regs)
Ffep-init
arguments:()
Ffep-term
arguments:()
Ffep-on
arguments:()
Ffep-off
arguments:()
Ffep-force-on
arguments:()
Ffep-force-off
arguments:()
Fpc98-assign-special-key
arguments:()
Fpc98-cancel-special-key
arguments:()
Vdos-machine-type
A symbol naming the dos-machine-type under which Emacs is running,
(such as `ibmpc'), or nil means running on dos generic mode.Vdos-inhibit-setdisk
*Non-nil means that changing current drive is inhibited.Vinhibit-fep-control
*Non-nil means that Kana-Kanji FEP control is inhibited.Fchar-to-string
Convert arg CHAR to a one-character string containing that character.
arguments:(n)
Fstring-to-char
Convert arg STRING to a character, the first character of that string.
arguments:(str)
Fpoint
Return value of point, as an integer.
Beginning of buffer is position (point-min)
arguments:()
Fpoint-marker
Return value of point, as a marker object.
This marker is a copy; you may modify it with reckless abandon.
If the argument to this function is non-nil, then it returns the real
point-marker; modifying the position of this marker willl move point.
It is illegal to change the buffer of it, or make it point nowhere.
arguments:(&optional dont_copy_p)
Fgoto-char
Set point to POSITION, a number or marker.
Beginning of buffer is position (point-min), end is (point-max).
arguments:(n)
Fregion-beginning
Return position of beginning of region, as an integer.
arguments:()
Fregion-end
Return position of end of region, as an integer.
arguments:()
Fzmacs-activate-region
Make the region between `point' and `mark' be in the active (hilighted)
state, if `zmacs-regions' is true. Only a very small number of commands
should ever do this.
arguments:()
Fzmacs-deactivate-region
Make the region between `point' and `mark' no longer be in the active
(hilighted) state, if `zmacs-regions' is true. You shouldn't need to call
this; the command loop calls it when appropriate.
Returns t if the region had been active, nil otherwise.
arguments:()
Fmark-marker
Return this buffer's mark, as a marker object.
If `zmacs-regions' is true, then this returns nil unless the region is
currently in the active (hilighted) state. With an argument of t, this
returns the mark (if there is one) regardless of the zmacs-region state.
You should *generally* not use the mark unless the region is active, if
the user has expressed a preference for the zmacs-region model.
Watch out! Moving this marker changes the mark position.
If you set the marker not to point anywhere, the buffer will have no mark.
arguments:(&optional inactive_p)
Fsave-excursion
Save point (and mark), execute BODY, then restore point and mark.
Executes BODY just like `progn'. Point and mark values are restored
even in case of abnormal exit (throw or error).
arguments: (&rest args)
Fbuffer-size
Return the number of characters in the current buffer.
arguments:()
Fpoint-min
Return the minimum permissible value of point in the current buffer.
This is 1, unless a clipping restriction is in effect.
arguments:()
Fpoint-min-marker
Return a marker to the minimum permissible value of point in this buffer.
This is the beginning, unless a clipping restriction is in effect.
arguments:()
Fpoint-max
Return the maximum permissible value of point in the current buffer.
This is (1+ (buffer-size)), unless a clipping restriction is in effect,
in which case it is less.
arguments:()
Fpoint-max-marker
Return a marker to the maximum permissible value of point in this buffer.
This is (1+ (buffer-size)), unless a clipping restriction is in effect,
in which case it is less.
arguments:()
Ffollowing-char
Return the character following point, as a number.
arguments:()
Fpreceding-char
Return the character preceding point, as a number.
arguments:()
Fbobp
Return T if point is at the beginning of the buffer.
If the buffer is narrowed, this means the beginning of the narrowed part.
arguments:()
Feobp
Return T if point is at the end of the buffer.
If the buffer is narrowed, this means the end of the narrowed part.
arguments:()
Fbolp
Return T if point is at the beginning of a line.
arguments:()
Feolp
Return T if point is at the end of a line.
`End of a line' includes point being at the end of the buffer.
arguments:()
Fchar-after
Return character in current buffer at position POS.
POS is an integer or a buffer pointer.
If POS is out of range, the value is nil.
arguments:(pos)
Fuser-login-name
Return the name under which the user logged in, as a string.
This is based on the effective uid, not the real uid.
Also, if the environment variable USER or LOGNAME is set,
that determines the value of this function.
arguments:()
Fuser-real-login-name
Return the name of the user's real uid, as a string.
Differs from `user-login-name' when running under `su'.
arguments:()
Fuser-uid
Return the effective uid of Emacs, as an integer.
arguments:()
Fuser-real-uid
Return the real uid of Emacs, as an integer.
arguments:()
Fuser-full-name
Return the full name of the user logged in, as a string.
arguments:()
Fsystem-name
Return the name of the machine you are running on, as a string.
arguments:()
Fcurrent-time-seconds
Returns the current time as the number of seconds since Jan. 1, 1970, 00:00,
Greenwich Mean Time. Since emacs can't represent integers that large, this
is returned as a cons of two 16-bit numbers. You can pass this value as an
argument to current-time-string to get that time as a string.
arguments:(&optional cons)
Fcurrent-time-string
Return the current time, as a human-readable string.
Programs can use it too, since the number of columns in each field is fixed.
The format is `Sun Sep 16 01:03:52 1973'.
If the optional argument is non-nil, it must be a cons of two integers, which
are the upper and lower 16 bits of a time in seconds (such as the value
returned by the current-time-seconds function.
In a future Emacs version, the time zone may be added at the end,
if we can figure out a reasonably easy way to get that information.
arguments:(&optional arg)
Fset-default-file-mode
Set Unix `umask' value to ARGUMENT, and return old value.
The `umask' value is the default protection mode for new files.
arguments:(nmask)
Funix-sync
Tell Unix to finish all pending disk updates.
arguments:()
Finsert
Insert the arguments, either strings or characters, at point.
Point moves forward so that it ends up after the inserted text.
Any other markers at the point of insertion remain before the text.
arguments: (&rest args)
Finsert-before-markers
Insert strings or characters at point, relocating markers after the text.
Point moves forward so that it ends up after the inserted text.
Any other markers at the point of insertion also end up after the text.
arguments: (&rest args)
Finsert-char
Insert COUNT (second arg) copies of CHAR (first arg).
Point and all markers are affected as in the function `insert'.
Both arguments are required.
arguments:(chr count)
Fbuffer-substring
Return the contents of part of the current buffer as a string.
The two arguments START and END are character positions;
they can be in either order.
arguments:(b e)
Fbuffer-string
Return the contents of the current buffer as a string.
arguments:()
Finsert-buffer-substring
Insert before point a substring of the contents buffer BUFFER.
BUFFER may be a buffer or a buffer name.
Arguments START and END are character numbers specifying the substring.
They default to the beginning and the end of BUFFER.
arguments:(buf &optional b e)
Fsubst-char-in-region
From START to END, replace FROMCHAR with TOCHAR each time it occurs.
If optional arg NOUNDO is non-nil, don't record this change for undo
and don't mark the buffer as really changed.
arguments:(start end fromchar tochar &optional noundo)
Ftranslate-region
From START to END, translate characters according to TABLE.
TABLE is a string; the Nth character in it is the mapping
for the character with code N. Returns the number of characters changed.
arguments:(start end table)
Fdelete-region
Delete the text between point and mark.
When called from a program, expects two arguments,
positions (integers or markers) specifying the stretch to be deleted.
arguments:(b e)
Fwiden
Remove restrictions (narrowing) from current buffer.
This allows the buffer's full text to be seen and edited.
arguments:()
Fnarrow-to-region
Restrict editing in this buffer to the current region.
The rest of the text becomes temporarily invisible and untouchable
but is not deleted; if you save the buffer in a file, the invisible
text is included in the file. \[widen] makes all visible again.
See also `save-restriction'.
When calling from a program, pass two arguments; positions (integers
or markers) bounding the text that should remain visible.
arguments:(b e)
Fsave-restriction
Execute BODY, saving and restoring current buffer's restrictions.
The buffer's restrictions make parts of the beginning and end invisible.
(They are set up with `narrow-to-region' and eliminated with `widen'.)
This special form, `save-restriction', saves the current buffer's restrictions
when it is entered, and restores them when it is exited.
So any `narrow-to-region' within BODY lasts only until the end of the form.
The old restrictions settings are restored
even in case of abnormal exit (throw or error).
The value returned is the value of the last form in BODY.
`save-restriction' can get confused if, within the BODY, you widen
and then make changes outside the area within the saved restrictions.
Note: if you are using both `save-excursion' and `save-restriction',
use `save-excursion' outermost:
(save-excursion (save-restriction ...))
arguments: (&rest args)
Fmessage
Print a one-line message at the bottom of the screen.
The first argument is a control string.
It may contain %s or %d or %c to print successive following arguments.
%s means print an argument as a string, %d means print as number in decimal,
%c means print a number as a single character.
The argument used by %s must be a string or a symbol;
the argument used by %d or %c must be a number.
arguments: (arg1 &rest args)
Fformat
Format a string out of a control-string and arguments.
The first argument is a control string.
The other arguments are substituted into it to make the result, a string.
It may contain %-sequences meaning to substitute the next argument.
%s means print strings using princ, and any other objects using prin1.
%S means print all objects using prin1 (strings too).
%d means print as number in decimal (%o octal, %x hex).
%c means print a number as a single character.
The argument used for %d, %o, %x or %c must be a number.
arguments: (arg1 &rest args)
Fchar-equal
Return t if two characters match, optionally ignoring case.
Both arguments must be characters (i.e. integers).
Case is ignored if `case-fold-search' is non-nil in the current buffer.
arguments:(c1 c2)
Fgetenv
Return the value of environment variable VAR, as a string.
VAR should be a string. Value is nil if VAR is undefined in the environment.
arguments:(str ignored)
Vsystem-name
The name of the machine Emacs is running on.Vuser-full-name
The full name of the user logged in.Vuser-name
The user's name, based on the effective uid.Vuser-real-name
The user's name, base upon the real uid.Vzmacs-regions
*Whether LISPM-style active regions should be used.
This means that commands which operate on the region (the area between the
point and the mark) will only work while the region is in the ``active''
state, which is indicated by hilighting. Executing most commands causes
the region to not be in the active state, so (for example) \[kill-region] will only
work immediately after activating the region.
More specifically:
- Commands which operate on the region only work if the region is active.
- Only a very small set of commands cause the region to become active:
Those commands whose semantics are to mark an area, like mark-defun.
- The region is deactivated after each command that is executed, except that:
- "Motion" commands do not change whether the region is active or not.
set-mark-command (C-SPC) pushes a mark and activates the region. Moving the
cursor with normal motion commands (C-n, C-p, etc) will cause the region
between point and the recently-pushed mark to be highlighted. It will
remain highlighted until some non-motion comand is executed.
exchange-point-and-mark (\[exchange-point-and-mark]) activates the region. So if you mark a
region and execute a command that operates on it, you can reactivate the
same region with \[exchange-point-and-mark] (or perhaps \[exchange-point-and-mark] \[exchange-point-and-mark]) to operate on it
again.
Generally, commands which push marks as a means of navigation (like
beginning-of-buffer and end-of-buffer (M-< and M->)) do not activate the
region. But commands which push marks as a means of marking an area of
text (like mark-defun (\[mark-defun]), mark-word (\[mark-word]) or mark-whole-buffer (\[mark-whole-buffer]))
do activate the region.Vzmacs-activate-region-hook
Function or functions called when the region becomes active;
see the variable `zmacs-regions'.Vzmacs-deactivate-region-hook
Function or functions called when the region becomes inactive;
see the variable `zmacs-regions'.Vzmacs-update-region-hook
Function or functions called when the active region changes.
This is called after each command that sets `region-stays' to t.
See the variable `zmacs-regions'.Vzmacs-region-stays
Commands which do not wish to affect whether the region is currently
hilighted should set this to t. Normally, the region is turned off after
executing each command that did not explicitly turn it on with the function
zmacs-activate-region. Setting this to true lets a command be non-intrusive.
See the variable `zmacs-regions'.Fhashtablep
Returns T if OBJ is a hashtable, else NIL.
arguments:(obj)
Fmake-hashtable
Make a hashtable of initial size SIZE.
arguments:(size)
Fcopy-hashtable
Make a new hashtable which contains the same keys and values
as the given table. The keys and values will not themselves be copied.
arguments:(old_table)
Fgethash
Find hash value for KEY in TABLE.
If there is no corresponding value, return DEFAULT (default nil)
arguments:(key table &optional defalt)
Fremhash
Remove hash value for KEY in TABLE.
arguments:(key table)
Fputhash
Hash KEY to VAL in TABLE.
arguments:(key val table)
Fclrhash
Flush TABLE.
arguments:(table)
Fhashtable-fullness
Returns number of entries in TABLE.
arguments:(table)
Fmaphash
Map FUNCTION over entries in TABLE, calling it with two args,
each key and value in the table.
arguments:(function table)
Frun-emacs-from-temacs
Do not call this. It will reinitialize your Emacs. You'll be sorry.
arguments: (&rest args)
Fkill-emacs
Exit the Emacs job and kill it. Ask for confirmation, without argument.
If ARG is an integer, return ARG as the exit program code.
If ARG is a string, stuff it as keyboard input.
The value of `kill-emacs-hook', if not void,
is a list of functions (of no args),
all of which are called before Emacs is actually killed.
arguments:(&optional arg)
Fdump-emacs
Dump current state of Emacs into executable file FILENAME.
Take symbols from SYMFILE (presumably the file you executed to run Emacs).
This is used in the file `loadup.el' when building Emacs.
Bind `command-line-processed' to nil before dumping,
if you want the dumped Emacs to process its command line
and announce itself normally when it is run.
arguments:(intoname symname)
Fnoninteractive
Non-nil return value means Emacs is running without interactive terminal.
arguments:()
Vcommand-line-args
Args passed by shell to Emacs, as a list of strings.Vinvocation-name
Name of file used to invoke editing session.
This is the same as `(file-name-nondirectory execution-path)'.Vexecution-path
Pathname of executable emacs program now running.Vsystem-type
Value is symbol indicating type of operating system you are using.Vnoninteractive
Non-nil means Emacs is running without interactive terminal.Fgetenv
Return the value of environment variable VAR, as a string.
When invoked interactively, print the value in the echo area.
VAR is a string, the name of the variable,
or the symbol t, meaning to return an alist representing the
current environment.
arguments:(str &optional interactivep)
Fsetenv
Set the value of environment variable VAR to VALUE.
Both args must be strings. Returns VALUE.
arguments:(str &optional val)
For
Eval args until one of them yields non-nil, then return that value.
The remaining args are not evalled at all.
If all args return nil, return nil.
arguments: (&rest args)
Fand
Eval args until one of them yields nil, then return nil.
The remaining args are not evalled at all.
If no arg yields nil, return the last arg's value.
arguments: (&rest args)
Fif
(if COND THEN ELSE...): if COND yields non-nil, do THEN, else do ELSE...
Returns the value of THEN or the value of the last of the ELSE's.
THEN must be one expression, but ELSE... can be zero or more expressions.
If COND yields nil, and there are no ELSE's, the value is nil.
arguments: (arg1 arg2 &rest args)
Fcond
(cond CLAUSES...): try each clause until one succeeds.
Each clause looks like (CONDITION BODY...). CONDITION is evaluated
and, if the value is non-nil, this clause succeeds:
then the expressions in BODY are evaluated and the last one's
value is the value of the cond-form.
If no clause succeeds, cond returns nil.
If a clause has one element, as in (CONDITION),
CONDITION's value if non-nil is returned from the cond-form.
arguments: (&rest args)
Fprogn
(progn BODY...): eval BODY forms sequentially and return value of last one.
arguments: (&rest args)
Fprog1
(prog1 FIRST BODY...): eval FIRST and BODY sequentially; value from FIRST.
The value of FIRST is saved during the evaluation of the remaining args,
whose values are discarded.
arguments: (arg1 &rest args)
Fprog2
(prog1 X Y BODY...): eval X, Y and BODY sequentially; value from Y.
The value of Y is saved during the evaluation of the remaining args,
whose values are discarded.
arguments: (arg1 arg2 &rest args)
Fsetq
(setq SYM VAL SYM VAL ...): set each SYM to the value of its VAL.
The SYMs are not evaluated. Thus (setq x y) sets x to the value of y.
Each SYM is set before the next VAL is computed.
arguments: (&rest args)
Fquote
Return the argument, without evaluating it. `(quote x)' yields `x'.
arguments: (arg1 &rest args)
Ffunction
Like `quote', but preferred for objects which are functions.
In byte compilation, `function' causes its argument to be compiled.
`quote' cannot do that.
arguments: (arg1 &rest args)
Finteractive-p
Return t if function in which this appears was called interactively.
This means that the function was called with call-interactively (which
includes being called as the binding of a key)
and input is currently coming from the keyboard (not in keyboard macro).
arguments:()
Fdefun
(defun NAME ARGLIST [DOCSTRING] BODY...): define NAME as a function.
The definition is (lambda ARGLIST [DOCSTRING] BODY...).
See also the function `interactive'.
arguments: (arg1 arg2 &rest args)
Fdefmacro
(defmacro NAME ARGLIST [DOCSTRING] BODY...): define NAME as a macro.
The definition is (macro lambda ARGLIST [DOCSTRING] BODY...).
When the macro is called, as in (NAME ARGS...),
the function (lambda ARGLIST BODY...) is applied to
the list ARGS... as it appears in the expression,
and the result should be a form to be evaluated instead of the original.
arguments: (arg1 arg2 &rest args)
Fdefvar
(defvar SYMBOL INITVALUE DOCSTRING): define SYMBOL as a variable.
You are not required to define a variable in order to use it,
but the definition can supply documentation and an initial value
in a way that tags can recognize.
INITVALUE is evaluated, and used to set SYMBOL, only if SYMBOL's value is void.
If SYMBOL is buffer-local, its default value is what is set;
buffer-local values are not affected.
INITVALUE and DOCSTRING are optional.
If DOCSTRING starts with *, this variable is identified as a user option.
This means that M-x set-variable and M-x edit-options recognize it.
If INITVALUE is missing, SYMBOL's value is not set.
arguments: (arg1 &rest args)
Fdefconst
(defconst SYMBOL INITVALUE DOCSTRING): define SYMBOL as a constant variable.
The intent is that programs do not change this value, but users may.
Always sets the value of SYMBOL to the result of evalling INITVALUE.
If SYMBOL is buffer-local, its default value is what is set;
buffer-local values are not affected.
DOCSTRING is optional.
If DOCSTRING starts with *, this variable is identified as a user option.
This means that M-x set-variable and M-x edit-options recognize it.
Note: do not use `defconst' for user options in libraries that are not
normally loaded, since it is useful for users to be able to specify
their own values for such variables before loading the library.
Since `defconst' unconditionally assigns the variable,
it would override the user's choice.
arguments: (arg1 arg2 &rest args)
Fuser-variable-p
Returns t if VARIABLE is intended to be set and modified by users.
(The alternative is a variable used internally in a Lisp program.)
Determined by whether the first character of the documentation
for the variable is "*"
arguments:(variable)
Flet*
(let* VARLIST BODY...): bind variables according to VARLIST then eval BODY.
The value of the last form in BODY is returned.
Each element of VARLIST is a symbol (which is bound to nil)
or a list (SYMBOL VALUEFORM) (which binds SYMBOL to the value of VALUEFORM).
Each VALUEFORM can refer to the symbols already bound by this VARLIST.
arguments: (arg1 &rest args)
Flet
(let VARLIST BODY...): bind variables according to VARLIST then eval BODY.
The value of the last form in BODY is returned.
Each element of VARLIST is a symbol (which is bound to nil)
or a list (SYMBOL VALUEFORM) (which binds SYMBOL to the value of VALUEFORM).
All the VALUEFORMs are evalled before any symbols are bound.
arguments: (arg1 &rest args)
Fwhile
(while TEST BODY...): if TEST yields non-nil, eval BODY... and repeat.
The order of execution is thus TEST, BODY, TEST, BODY and so on
until TEST returns nil.
arguments: (arg1 &rest args)
Fmacroexpand
Return result of expanding macros at top level of FORM.
If FORM is not a macro call, it is returned unchanged.
Otherwise, the macro is expanded and the expansion is considered
in place of FORM. When a non-macro-call results, it is returned.
The second optional arg ENVIRONMENT species an environment of macro
definitions to shadow the loaded ones for use in file byte-compilation.
arguments:(form &optional env)
Fcatch
(catch TAG BODY...): eval BODY allowing nonlocal exits using `throw'.
TAG is evalled to get the tag to use. Then the BODY is executed.
Within BODY, (throw TAG) with same tag exits BODY and exits this `catch'.
If no throw happens, `catch' returns the value of the last BODY form.
If a throw happens, it specifies the value to return from `catch'.
arguments: (arg1 &rest args)
Fthrow
(throw TAG VALUE): throw to the catch for TAG and return VALUE from it.
Both TAG and VALUE are evalled.
arguments:(tag val)
Funwind-protect
Do BODYFORM, protecting with UNWINDFORMS.
Usage looks like (unwind-protect BODYFORM UNWINDFORMS...).
If BODYFORM completes normally, its value is returned
after executing the UNWINDFORMS.
If BODYFORM exits nonlocally, the UNWINDFORMS are executed anyway.
arguments: (arg1 &rest args)
Fcondition-case
Regain control when an error is signaled.
Usage looks like (condition-case VAR BODYFORM HANDLERS...).
executes BODYFORM and returns its value if no error happens.
Each element of HANDLERS looks like (CONDITION-NAME BODY...)
where the BODY is made of Lisp expressions.
A handler is applicable to an error
if CONDITION-NAME is one of the error's condition names.
If an error happens, the first applicable handler is run.
When a handler handles an error,
control returns to the condition-case and the handler BODY... is executed
with VAR bound to (SIGNALED-CONDITIONS . SIGNAL-DATA).
VAR may be nil; then you do not get access to the signal information.
The value of the last BODY form is returned from the condition-case.
See also the function `signal' for more info.
arguments: (arg1 arg2 &rest args)
Fsignal
Signal an error. Args are SIGNAL-NAME, and associated DATA.
A signal name is a symbol with an `error-conditions' property
that is a list of condition names.
A handler for any of those names will get to handle this signal.
The symbol `error' should normally be one of them.
DATA should be a list. Its elements are printed as part of the error message.
If the signal is handled, DATA is made available to the handler.
See also the function `condition-case'.
arguments:(sig data)
Fcommandp
T if FUNCTION makes provisions for interactive calling.
This means it contains a description for how to read arguments to give it.
The value is nil for an invalid function or a symbol with no function
definition.
Interactively callable functions include strings and vectors (treated
as keyboard macros), lambda-expressions that contain a top-level call
to `interactive', autoload definitions made by `autoload' with non-nil
fourth argument, and some of the built-in functions of Lisp.
Also, a symbol satisfies `commandp' if its function definition does so.
arguments:(function)
Fautoload
Define FUNCTION to autoload from FILE.
FUNCTION is a symbol; FILE is a file name string to pass to `load'.
Third arg DOCSTRING is documentation for the function.
Fourth arg INTERACTIVE if non-nil says function can be called interactively.
Fifth arg MACRO if non-nil says the function is really a macro.
Third through fifth args give info about the real definition.
They default to nil.
If FUNCTION is already defined other than as an autoload,
this does nothing and returns nil.
arguments:(function file &optional docstring interactive macro)
Feval
Evaluate FORM and return its value.
arguments:(form)
Fapply
Call FUNCTION with our remaining args, using our last arg as list of args.
Thus, (apply '+ 1 2 '(3 4)) returns 10.
arguments: (arg1 arg2 &rest args)
Ffuncall
Call first argument as a function, passing remaining arguments to it.
Thus, (funcall 'cons 'x 'y) returns (x . y).
arguments: (arg1 &rest args)
Fbacktrace-debug
Set the debug-on-exit flag of eval frame LEVEL levels down to FLAG.
The debugger is entered when that frame exits, if the flag is non-nil.
arguments:(level flag)
Fbacktrace
Print a trace of Lisp function calls currently active.
Output stream used is value of `standard-output'.
arguments:(&optional stream)
Fbacktrace-frame
Return the function and arguments N frames up from current execution point.
If that frame has not evaluated the arguments yet (or is a special form),
the value is (nil FUNCTION ARG-FORMS...).
If that frame has evaluated its arguments and called its function already,
the value is (t FUNCTION ARG-VALUES...).
A &rest arg is represented as the tail of the list ARG-VALUES.
FUNCTION is whatever was supplied as car of evaluated list,
or a lambda expression for macro calls.
If N is more than the number of frames, the value is nil.
arguments:(nframes)
Vmax-specpdl-size
Limit on number of Lisp variable bindings & unwind-protects before error.Vmax-lisp-eval-depth
Limit on depth in `eval', `apply' and `funcall' before error.
This limit is to catch infinite recursions for you before they cause
actual stack overflow in C, which would be fatal for Emacs.
You can safely make it considerably larger than its default value,
if that proves inconveniently small.Vquit-flag
Non-nil causes `eval' to abort, unless `inhibit-quit' is non-nil.
Typing C-G sets `quit-flag' non-nil, regardless of `inhibit-quit'.Vinhibit-quit
Non-nil inhibits C-g quitting from happening immediately.
Note that `quit-flag' will still be set by typing C-g,
so a quit will be signalled as soon as `inhibit-quit' is nil.
To prevent this happening, set `quit-flag' to nil
before making `inhibit-quit' nil.Vstack-trace-on-error
*Non-nil means automatically display a backtrace buffer
after any error that is handled by the editor command loop.
If the value is a list, an error only means to display a backtrace
if one of its condition symbols appears in the list.Vdebug-on-error
*Non-nil means enter debugger if an error is signalled.
Does not apply to errors handled by `condition-case'.
If the value is a list, an error only means to enter the debugger
if one of its condition symbols appears in the list.
See also variable `debug-on-quit'.Vdebug-on-quit
*Non-nil means enter debugger if quit is signalled (C-G, for example).
Does not apply if quit is handled by a `condition-case'.Vdebug-on-next-call
Non-nil means enter debugger before next `eval', `apply' or `funcall'.Vdebugger
Function to call to invoke debugger.
If due to frame exit, args are `exit' and the value being returned;
this function's value will be returned instead of that.
If due to error, args are `error' and a list of the args to `signal'.
If due to `apply' or `funcall' entry, one arg, `lambda'.
If due to `eval' entry, one arg, t.Vmocklisp-arguments
While in a mocklisp function, the list of its unevaluated args.Vrun-hooks
Set to the function `run-hooks', if that function has been defined.
Otherwise, nil (in a bare Emacs without preloaded Lisp code).Fallocate-event
Returns an empty event structure.
WARNING, the event object returned may be a reused one; see the function
`deallocate-event'.
arguments:()
Fdeallocate-event
Allow the given event structure to be reused. You MUST NOT use this
event object after calling this function with it. You will lose.
It is not necessary to call this function, as event objects are garbage-
collected like all other objects; however, it may be more efficient to
explicitly deallocate events when you are sure that that is safe.
arguments:(event)
Fcopy-event
Make a copy of the given event object. If a second argument is given,
the first event is copied into the second and the second is returned.
If the second argument is not supplied (or is nil) then a new event will
be made as with `allocate-event.' See also the function `deallocate-event'.
arguments:(event1 &optional event2)
Finput-pending-p
T if command input is currently available with no waiting.
Actually, the value is nil only if we can be sure that no input is available.
arguments:()
Fenqueue-eval-event
Add an eval event to the back of the queue.
(enqueue-eval-event <function> <object>)
It will be the next event read after all pending events.
arguments:(function object)
Fnext-event
Given an event structure, fills it in with the next event available
from the window system or terminal driver. Pass this object to
dispatch-event to handle it. See also the function next-command-event,
which is often more appropriate.
arguments:(event)
Fnext-command-event
Given an event structure, fills it in with the next keyboard, mouse
press, or mouse release event available from the user. If there are
non-command events available (mouse motion, sub-process output, etc) then
these will be executed (with `dispatch-event') and discarded. This
function is provided as a convenience; it is equivalent to the elisp code
(while (progn
(next-event event)
(not (or (key-press-event-p event)
(button-press-event-p event)
(button-release-event-p event)
(menu-event-p event))))
(dispatch-event event))
arguments:(event)
Fread-char
Read a character from the command input (keyboard or macro).
If a mouse click is detected, an error is signalled. The character typed
is returned as an ASCII value. This is most likely the wrong thing for you
to be using: consider using the `next-command-event' function instead.
arguments:()
Fdiscard-input
Discard the contents of the terminal input buffer.
Also cancel any kbd macro being defined.
arguments:()
Faccept-process-output
Allow any pending output from subprocesses to be read by Emacs.
It is read into the process' buffers or given to their filter functions.
Non-nil arg PROCESS means do not return until some output has been received
from PROCESS.
arguments:(&optional proc)
Fsleep-for
Pause, without updating display, for ARG seconds.
ARG may be a float, meaning pause for some fractional part of a second.
arguments:(n)
Fsit-for
Perform redisplay, then wait for ARG seconds or until user input is
available. ARG may be a float, meaning a fractional part of a second.
Optional second arg non-nil means don't redisplay, just wait for input.
Redisplay is preempted as always if user input arrives, and does not
happen if input is available before it starts.
Value is t if waited the full time with no input arriving.
arguments:(n &optional nodisp)
Fsleep-for-millisecs
Pause, without updating display, for ARG milliseconds.
This function is obsolete; call `sleep-for' with a float instead.
arguments:(n)
Fadd-timeout
SECS is a number of seconds, expressed as an integer or a float.
FUNCTION will be called after that many seconds have elapsed, with one
argument, the given OBJECT. If the optional RESIGNAL argument is provided,
then after this timeout expires, `add-timeout' will automatically be called
again with RESIGNAL as the first argument.
This function returns an object which is the `id' of this particular timeout.
You can pass that object to `disable-timeout' to turn off the timeout before
it has been signalled.
The number of seconds may be expressed as a floating-point number, in which
case some fractional part of a second will be used. Caveat: the usable
timeout granularity will vary from system to system.
Adding a timeout causes a timeout event to be returned by `next-event', and
the function will be invoked by `dispatch-event,' so if emacs is in a tight
loop, the function will not be invoked until the next call to sit-for or
until the return to top-level (the same is true of process filters.)
arguments:(secs function object &optional resignal)
Fdisable-timeout
Given a timeout id number as returned by `add-timeout', this function
will cause that timeout to not be signalled if it hasn't been already.
arguments:(id)
Fdispatch-event
Given an event object returned by next-event, execute it.
arguments:(event)
Fread-key-sequence
Read a sequence of keystrokes or mouse clicks and return a vector of the
event objects read. The vector is newly created, but the event objects are
reused: if you want to hold a pointer to them beyond the next call to this
function, you must copy them first.
The sequence read is sufficient to specify a non-prefix command starting
from the current local and global keymaps. A C-g typed while in this
function is treated like any other character, and `quit-flag' is not set.
One arg, PROMPT, is a prompt string, or nil meaning do not prompt specially.
If the user selects a menu item while we are prompting for a key-sequence,
the returned value will be a vector of a single menu-selection event.
An error will be signalled if you pass this value to `lookup-key' or a
related function.
arguments:(prompt)
Vecho-keystrokes
*Nonzero means echo unfinished commands after this many seconds of pause.Vauto-save-interval
*Number of keyboard input characters between auto-saves.
Zero means disable autosaving due to number of characters typed.
See also the variable `auto-save-timeout'.Fevent-to-character
Returns the closest ASCII approximation to the given event object.
If the event isn't a keypress, this returns nil.
If the second argument is non-nil, then this is lenient in its
translation; it will ignore modifier keys other than control and meta,
and will ignore the shift modifier on those characters which have no
shifted ASCII equivalent (Control-Shift-A for example, will be mapped to
the same ASCII code as Control-A.) If the second arg is nil, then nil
will be returned for events which have no direct ASCII equivalent.
arguments:(event &optional lenient)
Fcharacter-to-event
Converts a numeric ASCII value to an event structure, replete with
bucky bits. The character is the first argument, and the event to fill
in is the second. This function contains knowledge about what the codes
``mean'' -- for example, the number 9 is converted to the character ``Tab'',
not the distinct character ``Control-I''.
If the optional second argument is an event, it is modified; otherwise, a
new event object is created.
Beware that character-to-event and event-to-character are not strictly
inverse functions, since events contain much more information than the
ASCII character set can encode.
arguments:(ch &optional event)
Feventp
True if the argument is an event object.
arguments:(obj)
Fkey-press-event-p
True if the argument is a key-press event object.
arguments:(obj)
Fbutton-press-event-p
True if the argument is a mouse-button-press event object.
arguments:(obj)
Fbutton-release-event-p
True if the argument is a mouse-button-release event object.
arguments:(obj)
Fbutton-event-p
True if the argument is a button-press or button-release event object.
arguments:(obj)
Fmotion-event-p
True if the argument is a mouse-motion event object.
arguments:(obj)
Fprocess-event-p
True if the argument is a process-output event object.
arguments:(obj)
Ftimeout-event-p
True if the argument is a timeout event object.
arguments:(obj)
Fmenu-event-p
True if the argument is a menu event object.
arguments:(obj)
Feval-event-p
True if the argument is an `eval' or `menu' event object.
arguments:(obj)
Fevent-timestamp
Returns the timestamp of the given event object.
arguments:(event)
Fevent-key
Returns the KeySym of the given key-press event. This will be the
ASCII code of a printing character, or a symbol.
arguments:(event)
Fevent-button
Returns the button-number of the given mouse-button-press event.
arguments:(event)
Fevent-modifier-bits
Returns a number representing the modifier keys which were down
when the given mouse or keyboard event was produced. See also the function
event-modifiers.
arguments:(event)
Fevent-modifiers
Returns a list of symbols, the names of the modifier keys which
were down when the given mouse or keyboard event was produced.
See also the function event-modifier-bits.
arguments:(event)
Fevent-x-pixel
Returns the X position of the given mouse-motion, button-press, or
button-release event in pixels.
arguments:(event)
Fevent-y-pixel
Returns the Y position of the given mouse-motion, button-press, or
button-release event in pixels.
arguments:(event)
Fevent-window
Given a mouse motion, button press, or button release event, compute
and return the window on which that event occurred. This may be nil if
the event did not occur in an emacs window (in the border or modeline.)
arguments:(event)
Fevent-point
Returns the character position of the given mouse-motion, button-press,
or button-release event. If the event did not occur over a window, or did
not occur over text, then this returns nil. Otherwise, it returns an index
into the buffer visible in the event's window.
arguments:(event)
Fevent-x
Returns the X position of the given mouse-motion, button-press, or
button-release event in characters.
arguments:(event)
Fevent-y
Returns the Y position of the given mouse-motion, button-press, or
button-release event in characters.
arguments:(event)
Fevent-glyph
If the given mouse-motion, button-press, or button-release event happened
on top of a glyph, this returns it; else nil.
arguments:(event)
Fevent-process
Returns the process of the given proces-output event.
arguments:(event)
Fevent-function
Returns the callback function of the given timeout, menu, or eval event.
arguments:(event)
Fevent-object
Returns the callback function argument of the given timeout, menu, or
eval event.
arguments:(event)
Vcharacter-set-property
A symbol used to look up the 8-bit character of a keysym.
To convert a keysym symbol to an 8-bit code, as when that key is
bound to self-insert-command, we will look up the property that this
variable names on the property list of the keysym-symbol. The window-
system-specific code will set up appropriate properties and set this
variable.Fmap-extents
Usage: (map-extents FUNCTION BUFFER FROM TO MAPARG)
Map FUNCTION over the extents which overlap region in BUFFER starting at
FROM and ending at TO. FUNCTION is called with arguments (extent, MAPARG).
All arguments except FUNCTION are optional, with FROM, TO, MAPARG, and
BUFFER defaulting to the beginning of BUFFER, the end of BUFFER, NIL, and
current buffer, respectively.
If the function returns non-nil, then map-extents returns immediately.
map-extents always returns nil.
arguments:(function &optional buffer from to maparg closed_end)
Fhighlight-extent
If EXTENT is `highlightable' (has the 'highlight property) then highlight
it (by using merging it with 'highlight face.) If FLAG is nil, then
unhighlight it instead.
arguments:(extent_obj &optional flag)
Fforce-highlight-extent
Highlight any EXTENT if FLAG is not nil, else unhighlight it.
This is the same as `highlight-extent', except that it will work even
on extents without the 'highlight property.
arguments:(extent_obj &optional flag)
Fextent-start-position
Return start position of EXTENT.
arguments:(extent_obj)
Fextent-end-position
Return first position after EXTENT.
arguments:(extent_obj)
Fextent-length
Return length of EXTENT in characters.
arguments:(extent_obj)
Fextent-buffer
Return buffer of EXTENT.
arguments:(extent_obj)
Fextent-to-generic-id
Return Energize ID of buffer of EXTENT.
arguments:(extent_obj)
Fmake-extent
Make extent for range [FROM, TO) in BUFFER -- BUFFER defaults to
current buffer. Insertions at point TO will be outside of the extent;
insertions at FROM will be inside the extent (and the extent will grow.)
arguments:(from to &optional buffer)
Fdelete-extent
Remove EXTENT from its buffer; this does not modify the buffer's text,
only its display properties.
arguments:(extent_obj)
Fupdate-extent
Set the endpoints of EXTENT to START, END.
arguments:(extent_obj start end)
Fset-extent-attribute
Make EXTENT have ATTRIBUTE.
ATTRIBUTE must be one of the following symbols:
highlight highlight when the mouse moves over it
write-protected text within this extent will be unmodifyable
invisible don't display the text in this region
unhighlight turn off `highlight'
writable turn off `write-protected'
visible turn off `invisible'
arguments:(extent_obj attr)
Fextent-attributes
Return a list of attributes of EXTENT.
This list may contain any or none of the following symbols:
highlight highlight when the mouse moves over it
write-protected text within this extent will be unmodifyable
invisible don't display the text in this region
begin-glyph there is a begin-glyph
end-glyph there is an end-glyph
detached the text around the extent has been deleted
arguments:(extent_obj &optional raw_p)
Fset-extent-begin-glyph
Display a bitmap at the beginning of the given extent.
The begin-glyph should be a string naming a bitmap file (or nil.)
arguments:(extent_obj begin_glyph)
Fset-extent-end-glyph
Display a bitmap at the end of the given extent.
The end-glyph should be a string naming a bitmap file (or nil.)
arguments:(extent_obj end_glyph)
Fextent-data
Return the user data associated with the given extent.
Set this using the `set-extent-data' function.
arguments:(extent)
Fset-extent-data
Set the user data slot of the given extent.
Access this using the `extent-data' function.
arguments:(extent data)
Fextent-priority
Returns the display priority of EXTENT; see `set-extent-priority'.
arguments:(extent)
Fset-extent-priority
Changes the display priority of EXTENT.
When the extent attributes are being merged for display, the priority
is used to determine which extent takes precedence in the event of a
conflict (two extents whose faces both specify font, for example: the
font of the extent with the higher priority will be used.)
Extents are created with priority 0; priorities may be negative.
arguments:(extent pri)
Fextent-at
Find "smallest" extent at POS in BUFFER having FLAG set. BUFFER
defaults to the current buffer, FLAG defaults to nil, meaning that any
extent will do. Possible values for FLAG are nil, 'menu, 'highlight,
'invisible, and 'write-protected. Returns nil if there is no matching
extent at POS.
arguments:(pos &optional buffer flag)
Fnext-extent
Find next extent after EXTENT. If EXTENT is a buffer
return the first extent in the buffer.
arguments:(extent_obj)
Fnext-e-extent
Find next extent after EXTENT using the "e" order. If
EXTENT is a buffer, return the first extent in the buffer.
arguments:(extent_obj)
Fstack-of-extents
Return stack of extents for BUFFER. Optional arg POSITION supplied
means compute the correct stack of extents for POSITION in BUFFER.
arguments:(buffer &optional position)
V buffer-of-current-extent-fragment
Buffer for current extent fragment -- this is a GC hack.Fscreen-face-alist
arguments:(screen)
Fset-screen-face-alist
arguments:(screen value)
Fmake-face-internal
arguments:(name object id_number)
Fset-face-attribute-internal
arguments:(face_id attr_name attr_value screen)
Vmouse-highlight-priority
The priority to use for the mouse-highlighting pseudo-extent
that is used to highlight extents with the `highlight' attribute set.
See `set-extent-priority'.Ffile-name-directory
Return the directory component in file name NAME.
Return nil if NAME does not include a directory.
Otherwise return a directory spec.
Given a Unix syntax file name, returns a string ending in slash;
on VMS, perhaps instead a string ending in `:', `]' or `>'.
arguments:(file)
Ffile-name-nondirectory
Return file name NAME sans its directory.
For example, in a Unix-syntax file name,
this is everything after the last slash,
or the entire name if it contains no slash.
arguments:(file)
Ffile-name-as-directory
Return a string representing file FILENAME interpreted as a directory.
This operation exists because a directory is also a file, but its name as
a directory is different from its name as a file.
The result can be used as the value of `default-directory'
or passed as second argument to `expand-file-name'.
For a Unix-syntax file name, just appends a slash.
On VMS, converts "[X]FOO.DIR" to "[X.FOO]", etc.
arguments:(file)
Fdirectory-file-name
Returns the file name of the directory named DIR.
This is the name of the file that holds the data for the directory DIR.
This operation exists because a directory is also a file, but its name as
a directory is different from its name as a file.
In Unix-syntax, this function just removes the final slash.
On VMS, given a VMS-syntax directory name such as "[X.Y]",
it returns a file name such as "[X]Y.DIR.1".
arguments:(directory)
Fmake-temp-name
Generate temporary file name (string) starting with PREFIX (a string).
The Emacs process number forms part of the result,
so there is no danger of generating a name being used by another process.
arguments:(prefix)
Fexpand-file-name
Convert FILENAME to absolute, and canonicalize it.
Second arg DEFAULT is directory to start with if FILENAME is relative
(does not start with slash); if DEFAULT is nil or missing,
the current buffer's value of default-directory is used.
Path components that are `.' are removed, and
path components followed by `..' are removed, along with the `..' itself;
note that these simplifications are done without checking the resulting
paths in the file system.
An initial `~/' expands to your home directory.
An initial `~USER/' expands to USER's home directory.
See also the function `substitute-in-file-name'.
arguments:(name &optional defalt)
Ftruename
Returns the canonical name of the given FILE.
Second arg DEFAULT is directory to start with if FILE is relative
(does not start with slash); if DEFAULT is nil or missing,
the current buffer's value of default-directory is used.
No component of the resulting pathname will be a symbolic link, as
in the realpath() function.
If the file does not exist, or is otherwise unable to be resolved,
nil is returned.
arguments:(name &optional defalt)
Fsubstitute-in-file-name
Substitute environment variables referred to in FILENAME.
`$FOO' where FOO is an environment variable name means to substitute
the value of that variable. The variable name should be terminated
with a character not a letter, digit or underscore; otherwise, enclose
the entire variable name in braces.
If `/~' appears, all of FILENAME through that `/' is discarded.
On VMS, `$' substitution is not done; this function does little and only
duplicates what `expand-file-name' does.
arguments:(string)
Fcopy-file
Copy FILE to NEWNAME. Both args must be strings.
Signals a `file-already-exists' error if file NEWNAME already exists,
unless a third argument OK-IF-ALREADY-EXISTS is supplied and non-nil.
A number as third arg means request confirmation if NEWNAME already exists.
This is what happens in interactive use with M-x.
Fourth arg KEEP-TIME non-nil means give the new file the same
last-modified time as the old one. (This works on only some systems.)
A prefix arg makes KEEP-TIME non-nil.
arguments:(filename newname &optional ok_if_already_exists keep_date)
Fmake-directory
Create a directory. One argument, a file name string.
arguments:(dirname)
Fremove-directory
Remove a directory. One argument, a file name string.
arguments:(dirname)
Fdelete-file
Delete specified file. One argument, a file name string.
If file has multiple names, it continues to exist with the other names.
arguments:(filename)
Frename-file
Rename FILE as NEWNAME. Both args strings.
If file has names other than FILE, it continues to have those names.
Signals a `file-already-exists' error if a file NEWNAME already exists
unless optional third argument OK-IF-ALREADY-EXISTS is non-nil.
A number as third arg means request confirmation if NEWNAME already exists.
This is what happens in interactive use with M-x.
arguments:(filename newname &optional ok_if_already_exists)
Fadd-name-to-file
Give FILE additional name NEWNAME. Both args strings.
Signals a `file-already-exists' error if a file NEWNAME already exists
unless optional third argument OK-IF-ALREADY-EXISTS is non-nil.
A number as third arg means request confirmation if NEWNAME already exists.
This is what happens in interactive use with M-x.
arguments:(filename newname &optional ok_if_already_exists)
Fmake-symbolic-link
Make a symbolic link to FILENAME, named LINKNAME. Both args strings.
Signals a `file-already-exists' error if a file NEWNAME already exists
unless optional third argument OK-IF-ALREADY-EXISTS is non-nil.
A number as third arg means request confirmation if NEWNAME already exists.
This happens for interactive use with M-x.
arguments:(filename newname &optional ok_if_already_exists)
Fdefine-logical-name
Define the job-wide logical name NAME to have the value STRING.
If STRING is nil or a null string, the logical name NAME is deleted.
arguments:(varname string)
Fsysnetunam
Open a network connection to PATH using LOGIN as the login string.
arguments:(path login)
Ffile-name-absolute-p
Return t if file FILENAME specifies an absolute path name.
On Unix, this is a name starting with a `/' or a `~'.
arguments:(filename)
Ffile-exists-p
Return t if file FILENAME exists. (This does not mean you can read it.)
See also `file-readable-p' and `file-attributes'.
arguments:(filename)
Ffile-executable-p
Return t if FILENAME can be executed by you.
For directories this means you can change to that directory.
arguments:(filename)
Ffile-readable-p
Return t if file FILENAME exists and you can read it.
See also `file-exists-p' and `file-attributes'.
arguments:(filename)
Ffile-symlink-p
If file FILENAME is the name of a symbolic link
returns the name of the file to which it is linked.
Otherwise returns NIL.
arguments:(filename)
Ffile-writable-p
Return t if file FILENAME can be written or created by you.
arguments:(filename)
Ffile-directory-p
Return t if file FILENAME is the name of a directory as a file.
A directory name spec may be given instead; then the value is t
if the directory so specified exists and really is a directory.
arguments:(filename)
Ffile-modes
Return mode bits of FILE, as an integer.
arguments:(filename)
Fset-file-modes
Set mode bits of FILE to MODE (an integer).
Only the 12 low bits of MODE are used.
arguments:(filename mode)
Ffile-newer-than-file-p
Return t if file FILE1 is newer than file FILE2.
If FILE1 does not exist, the answer is nil;
otherwise, if FILE2 does not exist, the answer is t.
arguments:(file1 file2)
Finsert-file-contents
Insert contents of file FILENAME after point.
Returns list of absolute pathname and length of data inserted.
If second argument VISIT is non-nil, the buffer's visited filename
and last save file modtime are set, and it is marked unmodified.
If visiting and the file does not exist, visiting is completed
before the error is signaled.
arguments:(filename &optional visit)
Fwrite-region
Write current region into specified file.
When called from a program, takes three arguments:
START, END and FILENAME. START and END are buffer positions.
Optional fourth argument APPEND if non-nil means
append to existing file contents (if any).
Optional fifth argument VISIT if t means
set the last-save-file-modtime of buffer to this file's modtime
and mark buffer not modified.
If VISIT is neither t nor nil, it means do not print
the "Wrote file" message.
Kludgy feature: if START is a string, then that string is written
to the file, instead of any buffer contents, and END is ignored.
arguments:(start end filename &optional append visit)
Fencrypt-string
Encrypt STRING using KEY.
arguments:(string key)
Fdecrypt-string
Decrypt STRING using KEY.
arguments:(string key)
Fverify-visited-file-modtime
Return t if last mod time of BUF's visited file matches what BUF records.
This means that the file has not been changed since it was visited or saved.
arguments:(buf)
Fclear-visited-file-modtime
Clear out records of last mod time of visited file.
Next attempt to save will certainly not complain of a discrepancy.
arguments:()
Fset-visited-file-modtime
Update buffer's recorded modification time from the visited file's time.
Useful if the buffer was not read from the file normally
or if the file itself has been changed for some known benign reason.
arguments:()
Fset-buffer-modtime
Update BUFFER's recorded modification time from the associated
file's modtime, if there is an associated file. If not, use the
current time. In either case, if the optional arg TIME is supplied, use
that is it is either an integer or a cons of two integers.
arguments:(buf &optional in_time)
Fdo-auto-save
Auto-save all buffers that need it.
This is all buffers that have auto-saving enabled
and are changed since last auto-saved.
Auto-saving writes the buffer into a file
so that your editing is not lost if the system crashes.
This file is not the file you visited; that changes only when you save.
Non-nil first argument means do not print any message if successful.
arguments:(&optional nomsg)
Fset-buffer-auto-saved
Mark current buffer as auto-saved with its current text.
No auto-save file will be written until the buffer changes again.
arguments:()
Frecent-auto-save-p
Return t if buffer has been auto-saved since last read in or saved.
arguments:()
Vvms-stmlf-recfm
*Non-nil means write new files with record format `stmlf'.
nil means use format `var'. This variable is meaningful only on VMS.Flock-buffer
Lock FILE, if current buffer is modified.
FILE defaults to current buffer's visited file,
or else nothing is done if current buffer isn't visiting a file.
arguments:(&optional fn)
Funlock-buffer
Unlock the file visited in the current buffer,
if it should normally be locked.
arguments:()
Ffile-locked-p
Return nil if the FILENAME is not locked,
t if it is locked by you, else a string of the name of the locker.
arguments:(&optional fn)
Vlock-directory
Don't change thisVsuperlock-path
Don't change thisFacos
Return the inverse cosine of ARG.
arguments:(arg)
Facosh
Return the inverse hyperbolic cosine of ARG.
arguments:(arg)
Fasin
Return the inverse sine of ARG.
arguments:(arg)
Fasinh
Return the inverse hyperbolic sine of ARG.
arguments:(arg)
Fatan
Return the inverse tangent of ARG.
arguments:(arg1 &optional arg2)
Fatanh
Return the inverse hyperbolic tangent of ARG.
arguments:(arg)
Fcos
Return the cosine of ARG.
arguments:(arg)
Fcosh
Return the hyperbolic cosine of ARG.
arguments:(arg)
Fcube-root
Return the cube root of ARG.
arguments:(arg)
Fexp
Return the exponential base e of ARG.
arguments:(arg)
Flog
Return the natural logarithm of ARG.
With two arguments, return the logarithm of ARG to the base ARG2.
arguments:(arg1 &optional arg2)
Flog10
Return the logarithm base 10 of ARG.
arguments:(arg)
Fexpt
Return the exponential x ** y.
arguments:(arg1 arg2)
Fsin
Return the sine of ARG.
arguments:(arg)
Fsinh
Return the hyperbolic sine of ARG.
arguments:(arg)
Fsqrt
Return the square root of ARG.
arguments:(arg)
Ftan
Return the tangent of ARG.
arguments:(arg)
Ftanh
Return the hyperbolic tangent of ARG.
arguments:(arg)
Fabs
Return the absolute value of ARG.
arguments:(arg)
Ffloat
Return the floating point number equal to ARG.
arguments:(arg)
Fceiling
Return the smallest integer no less than ARG. (Round toward +inf.)
arguments:(arg)
Ffloor
Return the largest integer no greater than ARG. (Round towards -inf.)
arguments:(arg)
Fround
Return the nearest integer to ARG.
arguments:(arg)
Ftruncate
Truncate a floating point number to an int.
Rounds the value toward zero.
arguments:(arg)
Ffceiling
Return the smallest integer no less than ARG, as a float.
(Round toward +inf.)
arguments:(arg)
Fffloor
Return the largest integer no greater than ARG, as a float.
(Round towards -inf.)
arguments:(arg)
Ffround
Return the nearest integer to ARG, as a float.
arguments:(arg)
Fftruncate
Truncate a floating point number to an integral float value.
Rounds the value toward zero.
arguments:(arg)
Fidentity
Return the argument unchanged.
arguments:(arg)
Frandom
Return a pseudo-random number.
On most systems all integers representable in Lisp are equally likely.
This is 24 bits' worth.
With argument N, return random number in interval [0,N).
With argument t, set the random number seed from the current time and pid.
arguments:(&optional arg)
Flength
Return the length of vector, list or string SEQUENCE.
A byte-code function object is also allowed.
arguments:(obj)
Fstring-equal
T if two strings have identical contents.
Case is significant.
Symbols are also allowed; their print names are used instead.
arguments:(s1 s2)
Fstring-lessp
T if first arg string is less than second in lexicographic order.
Case is significant.
Symbols are also allowed; their print names are used instead.
arguments:(s1 s2)
Fappend
Concatenate all the arguments and make the result a list.
The result is a list whose elements are the elements of all the arguments.
Each argument may be a list, vector or string.
The last argument is not copied if it is a list.
arguments: (&rest args)
Fconcat
Concatenate all the arguments and make the result a string.
The result is a string whose elements are the elements of all the arguments.
Each argument may be a string, a list of numbers, or a vector of numbers.
arguments: (&rest args)
Fvconcat
Concatenate all the arguments and make the result a vector.
The result is a vector whose elements are the elements of all the arguments.
Each argument may be a list, vector or string.
arguments: (&rest args)
Fcopy-sequence
Return a copy of a list, vector or string.
The elements of a list or vector are not copied; they are shared
with the original.
arguments:(arg)
Fcopy-alist
Return a copy of ALIST.
This is an alist which represents the same mapping from objects to objects,
but does not share the alist structure with ALIST.
The objects mapped (cars and cdrs of elements of the alist)
are shared, however.
arguments:(alist)
Fcopy-tree
Return a copy of a list or vector, and substructures.
The argument is copied, and any lists or vectors contained within it
are copied recursively. Circularities and shared substructures are
not preserved. Strings are not copied.
arguments:(arg)
Fsubstring
Return a substring of STRING, starting at index FROM and ending before TO.
TO may be nil or omitted; then the substring runs to the end of STRING.
If FROM or TO is negative, it counts from the end.
arguments:(string from &optional to)
Fnthcdr
Take cdr N times on LIST, returns the result.
arguments:(n list)
Fnth
Return the Nth element of LIST.
N counts from zero. If LIST is not that long, nil is returned.
arguments:(n list)
Felt
Return element of SEQUENCE at index N.
arguments:(seq n)
Fmember
Return non-nil if ELT is an element of LIST. Comparison done with EQUAL.
The value is actually the tail of LIST whose car is ELT.
arguments:(elt list)
Fmemq
Return non-nil if ELT is an element of LIST. Comparison done with EQ.
The value is actually the tail of LIST whose car is ELT.
arguments:(elt list)
Fassq
Return non-nil if ELT is `eq' to the car of an element of LIST.
The value is actually the element of LIST whose car is ELT.
arguments:(key list)
Fassoc
Return non-nil if ELT is `equal' to the car of an element of LIST.
The value is actually the element of LIST whose car is ELT.
arguments:(key list)
Frassq
Return non-nil if ELT is `eq' to the cdr of an element of LIST.
The value is actually the element of LIST whose cdr is ELT.
arguments:(key list)
Fdelq
Delete by side effect any occurrences of ELT as a member of LIST.
The modified LIST is returned. Comparison is done with `eq'.
If the first member of LIST is ELT, there is no way to remove it by side effect;
therefore, write `(setq foo (delq element foo))'
to be sure of changing the value of `foo'.
arguments:(elt list)
Fdelete
Delete by side effect any occurrences of ELT as a member of LIST.
The modified LIST is returned. Comparison is done with `equal'.
If the first member of LIST is ELT, there is no way to remove it by side effect;
therefore, write `(setq foo (delete element foo))'
to be sure of changing the value of `foo'.
arguments:(elt list)
Fnreverse
Reverse LIST by modifying cdr pointers.
Returns the beginning of the reversed list.
arguments:(list)
Freverse
Reverse LIST, copying. Returns the beginning of the reversed list.
See also the function `nreverse', which is used more often.
arguments:(list)
Fsort
Sort LIST, stably, comparing elements using PREDICATE.
Returns the sorted list. LIST is modified by side effects.
PREDICATE is called with two elements of LIST, and should return T
if the first element is "less" than the second.
arguments:(list pred)
Fget
Return the value of SYMBOL's PROPNAME property.
This is the last VALUE stored with `(put SYMBOL PROPNAME VALUE)'.
arguments:(sym prop)
Fput
Store SYMBOL's PROPNAME property with value VALUE.
It can be retrieved with `(get SYMBOL PROPNAME)'.
arguments:(sym prop val)
Fremprop
Remove from SYMBOL's plist the property PROP and its value.
arguments:(symbol property)
Fequal
T if two Lisp objects have similar structure and contents.
They must have the same data type.
Conses are compared by comparing the cars and the cdrs.
Vectors and strings are compared element by element.
Numbers are compared by value. Symbols must match exactly.
arguments:(o1 o2)
Ffillarray
Store each element of ARRAY with ITEM. ARRAY is a vector or string.
arguments:(array item)
Fnconc
Concatenate any number of lists by altering them.
Only the last argument is not altered, and need not be a list.
arguments: (&rest args)
Fmapconcat
Apply FN to each element of SEQ, and concat the results as strings.
In between each pair of results, stick in SEP.
Thus, " " as SEP results in spaces between the values return by FN.
arguments:(fn seq sep)
Fmapcar
Apply FUNCTION to each element of SEQUENCE, and make a list of the results.
The result is a list just as long as SEQUENCE.
SEQUENCE may be a list, a vector or a string.
arguments:(fn seq)
Fload-average
Return list of 1 minute, 5 minute and 15 minute load averages.
Each of the three load averages is multiplied by 100,
then converted to integer.
This won't work unless the emacs executable is setgid kmem
(assuming that /dev/kmem is in the group kmem.)
arguments:()
Ffeaturep
Returns t if FEATURE is present in this Emacs.
Use this to conditionalize execution of lisp code based on the presence or
absence of emacs or environment extensions.
Use `provide' to declare that a feature is available.
This function looks at the value of the variable `features'.
arguments:(feature)
Fprovide
Announce that FEATURE is a feature of the current Emacs.
arguments:(feature)
Frequire
If feature FEATURE is not loaded, load it from FILENAME.
If FEATURE is not a member of the list `features', then the feature
is not loaded; so load the file FILENAME.
If FILENAME is omitted, the printname of FEATURE is used as the file name.
arguments:(feature &optional file_name)
Fplay-sound-file
Play the named sound file on the console speaker at the specified volume
(0-100, default specified by the `bell-volume' variable).
The sound file must be in the Sun/NeXT U-LAW format.
arguments:(file &optional vol)
Fplay-sound
Play a sound of the provided type.
See the variable sound-alist.
arguments:(sound &optional volume)
Vfeatures
A list of symbols which are the features of the executing emacs.
Used by `featurep' and `require', and altered by `provide'.Vbell-volume
How loud to be, from 0 to 100.Vsound-alist
An alist associating symbols with strings of audio-data.
When `beep' or `ding' is called with one of the symbols, the associated
sound data will be played instead of the standard beep. This only works
if you are logged in on the console of a Sun SparcStation or SGI machine.
Elements of this list should be of one of the following forms:
( symbol . string-or-symbol )
( symbol integer string-or-symbol )
If the `string-or-symbol' is a string, then it should contain raw sound data,
the contents of a `.au' file. If it is a symbol, then that means that this
element is an alias for some other element, and the sound-player will look
for that next. If the integer is provided, it is the volume at which the
sound should be played, from 0 to 100.
If an element of this alist begins with the symbol `default', then that sound
will be used when no other sound is appropriate.
The symbol `t' in place of a sound-string means to use the default X beep.
In this way, you can define beep-types to have different volumes even when
not running on the console of a Sun4.
You should probably add things to this list by calling the function
load-sound-file.
The following beep-types are used by emacs itself:
auto-save-error when an auto-save does not succeed
command-error when the emacs command loop catches an error
undefined-key when you type a key that is undefined
undefined-click when you use an undefined mouse-click combination
no-completion during completing-read
y-or-n-p when you type something other than 'y' or 'n'
yes-or-no-p when you type something other than 'yes' or 'no'
Other lisp packages may use other beep types, but these are the ones that
the C kernel of emacs uses.Fbuffer-syntactic-context-flush-cache
Flush the cache used by `buffer-syntactic-context-flush-cache'.
Call this when deletions occur. This is a kludge.
arguments:()
Fbuffer-syntactic-context
Returns the syntactic context of the current buffer at point.
The returned value is one of the following symbols:
nil ; meaning no special interpretation
string ; meaning point is within a string
comment ; meaning point is within a line comment
block-comment ; meaning point is within a block comment
See also the function `buffer-syntactic-context-depth', which returns
the current nesting-depth within all parenthesis-syntax delimiters
and the function `syntactically-sectionize', which will map a function
over each syntactic context in a region.
arguments:()
Fbuffer-syntactic-context-depth
Returns the depth within all parenthesis-syntax delimiters at point.
arguments:()
Fsyntactically-sectionize
Creates extents for each contiguous syntactic context in the region.
Calls the given function when each extent is created with three arguments:
the extent, a symbol representing the syntactic context, and the current
depth (as returned by the functions `buffer-syntactic-context' and
`buffer-syntactic-context-depth'). If the optional arg `extent-data' is
provided, the extent will be created with that in its data slot.
arguments:(start end function &optional extent_data)
Fcurrent-column
Return the horizontal position of point. Beginning of line is column 0.
This is calculated by adding together the widths of all the displayed
representations of the character between the start of the previous line
and point. (eg control characters will have a width of 2 or 4, tabs
will have a variable width)
Ignores finite width of screen, which means that this function may return
values greater than (screen-width).
Whether the line is visible (if `selective-display' is t) has no effect;
however, ^M is treated as end of line when `selective-display' is t.
arguments:()
Findent-to
Indent from point with tabs and spaces until COLUMN is reached.
Optional second argument MIN says always do at least MIN spaces
even if that goes past COLUMN; by default, MIN is zero.
arguments:(col &optional minimum)
Fcurrent-indentation
Return the indentation of the current line.
This is the horizontal position of the character
following any initial whitespace.
arguments:()
Fmove-to-column
Move point to column COLUMN in the current line.
The column of a character is calculated by adding together the widths
as displayed of the previous characters in the line.
This function ignores line-continuation;
there is no upper limit on the column number a character can have
and horizontal scrolling has no effect.
If specified column is within a character, point goes after that character.
If it's past end of line, point goes to end of line.
A non-nil second (optional) argument FORCE means, if the line
is too short to reach column COLUMN then add spaces/tabs to get there,
and if COLUMN is in the middle of a tab character, change it to spaces.
arguments:(column &optional force)
Fmotion
Move forward from point by N characters. Stop if we reach
TOHPOS, TOVPOS first.
arguments:(n tohpos tovpos)
Fvertical-motion
Move to start of screen line LINES lines down.
If LINES is negative, this is moving up.
Sets point to position found; this may be start of line
or just the start of a continuation line.
Returns number of lines moved; may be closer to zero than LINES
if beginning or end of buffer was reached.
Optional second argument is WINDOW to move in.
arguments:(lines &optional window)
Vindent-tabs-mode
*Indentation can insert tabs if this is non-nil.
Setting this variable automatically makes it local to the current buffer.Frecursive-edit
Invoke the editor command loop recursively.
To get out of the recursive edit, a command can do `(throw 'exit nil)';
that tells this function to return.
Alternately, `(throw 'exit t)' makes this function signal an error.
This function is called by the editor initialization to begin editing.
arguments:()
Ftop-level
Exit all recursive editing levels.
arguments:()
Fexit-recursive-edit
Exit from the innermost recursive edit or minibuffer.
arguments:()
Fabort-recursive-edit
Abort the command that requested this recursive edit or minibuffer input.
arguments:()
Fcommand-execute
Execute CMD as an editor command.
CMD must be a symbol that satisfies the `commandp' predicate.
Optional second arg RECORD-FLAG non-nil
means unconditionally put this command in `command-history'.
Otherwise, that is done only if an arg is read using the minibuffer.
arguments:(cmd &optional record)
Frecent-keys
Return vector of last 100 keyboard or mouse button events read.
This copies 100 event objects and a vector; it is safe to keep and modify
them.
arguments:()
Fthis-command-keys
Returns a vector of the keyboard or mouse button events that were used
to invoke this command. This copies the vector and the events; it is safe
to keep and modify them.
arguments:()
Frecursion-depth
Return the current depth in recursive edits.
arguments:()
Fopen-dribble-file
Start writing all keyboard characters to FILE.
arguments:(file)
Fsuspend-emacs
Stop Emacs and return to superior process. You can resume later.
If optional arg STUFFSTRING is non-nil, its characters are stuffed
to be read as terminal input by Emacs's superior shell.
Before suspending, if `suspend-hook' is bound and value is non-nil
call the value as a function of no args. Don't suspend if it returns non-nil.
Otherwise, suspend normally and after resumption call
`suspend-resume-hook' if that is bound and non-nil.
arguments:(&optional stuffstring)
Fset-input-mode
Set mode of reading keyboard input.
First arg non-nil means use input interrupts; nil means use CBREAK mode.
Second arg non-nil means use ^S/^Q flow control for output to terminal
(no effect except in CBREAK mode).
Third arg non-nil means accept 8-bit input (for a Meta key).
Otherwise, the top bit is ignored, on the assumption it is parity.
arguments:(intrrupt flow meta)
Fset-interrupt-character
Change the interrupt character. Arg is an ASCII code or nil.
Among other system-dependent things, this changes the value of the
variable `interrupt-char'.
arguments:(new_interrupt_char)
Vdisabled-command-hook
Value is called instead of any command that is disabled,
i.e. has a non-nil `disabled' property.Vlast-command-event
Last keyboard or mouse button event that was part of a command. This
variable is off limits: you may not set its value or modify the event that
is its value, as it is destructively modified by `read-key-sequence'. If
you want to keep a pointer to this value, you must use `copy-event'.Vlast-command-char
If the value of `last-command-event' is a keyboard event, then
this is the nearest ASCII equivalent to it. This the the value that
`self-insert-command' will put in the buffer. Remember that there is
NOT a 1:1 mapping between keyboard events and ASCII characters: the set
of keyboard events is much larger, so writing code that examines this
variable to determine what key has been typed is bad practice, unless
you are certain that it will be one of a small set of characters.Vlast-input-event
Last keyboard or mouse button event recieved. This variable is off
limits: you may not set its value or modify the event that is its value, as
it is destructively modified by `next-event'. If you want to keep a pointer
to this value, you must use `copy-event'.Vlast-input-char
If the value of `last-input-event' is a keyboard event, then
this is the nearest ASCII equivalent to it. Remember that there is
NOT a 1:1 mapping between keyboard events and ASCII characters: the set
of keyboard events is much larger, so writing code that examines this
variable to determine what key has been typed is bad practice, unless
you are certain that it will be one of a small set of characters.Vlast-input-time
The time (in seconds since Jan 1, 1970) of the last-command-event,
represented as a cons of two 16-bit integers. This is destructively
modified, so copy it if you want to keep it.Vunread-command-event
Set this to an event object to simulate the reciept of an event from
the user. Normally this is nil.Vlast-command
The last command executed. Normally a symbol with a function definition,
but can be whatever was found in the keymap, or whatever the variable
`this-command' was set to by that command.Vthis-command
The command now being executed.
The command can set this variable; whatever is put here
will be in `last-command' during the following command.Vhelp-char
Character to recognize as meaning Help.
When it is read, do `(eval help-form)', and display result if it's a string.
If the value of `help-form' is nil, this char can be read normally.Vinterrupt-char
Character which interrupts emacs.
Do not setq this variable: use the function `set-interrupt-character' instead.
Depending on the system you are on, this may need to do magic like changing
interrupt handlers.Vhelp-form
Form to execute when character help-char is read.
If the form returns a string, that string is displayed.
If `help-form' is nil, the help char is not recognized.Vpre-command-hook
Function or functions to run before every command.
This may examine the `this-command' variable to find out what command
is about to be run, or may change it to cause a different command to run.
Function on this hook must be careful to avoid signalling errors!Vpost-command-hook
Function or functions to run after every command.
This may examine the `this-command' variable to find out what command
was just executed.Vtop-level
Form to evaluate when Emacs starts up.
Useful to set before you dump a modified Emacs.Vkeyboard-translate-table
String used as translate table for keyboard input, or nil.
Each character is looked up in this string and the contents used instead.
If string is of length N, character codes N and up are untranslated.
This is the right thing to use only if you are on a dumb tty, as it cannot
handle input which cannot be represented as ASCII. If you are running emacs
under X, you should do the translations with the `xmodmap' program instead.Fmake-keymap
Construct and return a new keymap object. All entries in it are nil,
meaning "command undefined".
arguments:()
Fmake-sparse-keymap
Construct and return a new keymap object. All entries in it are nil,
meaning "command undefined". The only difference between this function
and make-keymap is that this function returns a "smaller" keymap (one
that is expected to contain less entries.) As keymaps dynamically resize,
the distinction is not great.
arguments:()
Fkeymap-parent
Returns the `parent' keymap of the given keymap, or nil.
The parent of a keymap is searched for keybindings when a key sequence
isn't bound in this one. The (current-global-map) is the default parent
of all keymaps.
arguments:(keymap)
Fset-keymap-parent
Sets the `parent' keymap of the given keymap.
The parent of a keymap is searched for keybindings when a key sequence
isn't bound in this one. The (current-global-map) is the default parent
of all keymaps.
arguments:(keymap parent)
Fset-keymap-name
Sets the `name' of the given keymap to NEW-NAME
The name is only a debugging convenience; it is not used except
when printing the keymap.
arguments:(keymap new_name)
Fkeymapp
Return t if ARG is a keymap object.
arguments:(object)
Fcopy-keymap
Return a copy of the keymap KEYMAP.
The copy starts out with the same definitions of KEYMAP,
but changing either the copy or KEYMAP does not affect the other.
Any key definitions that are subkeymaps are recursively copied.
arguments:(keymap)
Fkeymap-fullness
Returns the number of bindings in the keymap.
arguments:(keymap)
Fdefine-key
Args KEYMAP, KEYS, DEF. Define key sequence KEYS, in KEYMAP, as DEF.
KEYMAP is a keymap object.
KEYS is the sequence of keystrokes to bind, described below.
DEF is anything that can be a key's definition:
nil (means key is undefined in this keymap);
a command (a Lisp function suitable for interactive calling);
a string or key sequence vector (treated as a keyboard macro);
a keymap (to define a prefix key);
a symbol; when the key is looked up, the symbol will stand for its
function definition, that should at that time be one of the above,
or another symbol whose function definition is used, and so on.
a cons (STRING . DEFN), meaning that DEFN is the definition
(DEFN should be a valid definition in its own right);
or a cons (KEYMAP . CHAR), meaning use definition of CHAR in map KEYMAP.
Contrary to popular belief, the world is not ASCII. When running under a
window manager, Emacs can tell the difference between, for example, the
keystrokes control-h, control-shift-h, and backspace. You can, in fact,
bind different commands to each of these.
A `key sequence' is a set of keystrokes. A `keystroke' is a keysym and some
set of modifiers (such as control and meta). A `keysym' is what is printed
on the keys on your keyboard.
A keysym may be represented by a symbol, or (if and only if it is equivalent
to a printing ASCII character) by its ASCII code. The `A' key may be
represented by the symbol `A' or by the number 65. The `break' key may be
represented only by the symbol `break'.
A keystroke may be represented by a list: the last element of the list is
the key (a symbol or number, as above) and the preceding elements are the
symbolic names of modifier keys (control, meta, super, hyper, and shift.)
Thus, the sequence control-b is represented by the forms `(control b)'
and `(control 98)'. A keystroke may also be represented by an event object,
as returned by the `next-command-event' and `read-key-sequence' functions.
Note that in this context, the keystroke `control-b' is *not* represented
by the number 2 (the ASCII code for ^B). See below.
The `shift' modifier is somewhat of a special case. You should not (and
cannot) use `(meta shift a)' to mean `(meta A)', since for characters that
have printing ASCII equivalents, the state of the shift key is implicit in
the keysym (a vs. A). You also cannot say `(shift =)' to mean `+', as that
sort of thing varies from keyboard to keyboard. The shift modifier is for
use only with characters that do not have a second keysym on the same key,
such as `backspace' and `tab'.
A key sequence is a vector of keystrokes. As a degenerate case, elements
of this vector may also be keysyms if they have no modifiers. That is,
the `A' keystroke is represented by all of these forms:
A 65 (A) (65) [A] [65] [(A)] [(65)]
the `control-a' keystroke is represented by these forms:
(control A) (control 65) [(control A)] [(control 65)]
the key sequence `control-c control-a' is represented by these forms:
[(control c) (control a)] [(control 99) (control 65)]
Mouse button clicks work just like keypresses: (control button1) means
pressing the left mouse button while holding down the control key.
[(control c) (shift button3)] means control-c, hold shift, click right.
Commands may be bound to the mouse-button up-stroke rather than the down-
stroke as well. `button1' means the down-stroke, and `button1up' means the
up-stroke. Different commands may be bound to the up and down strokes,
though that is probably not what you want, so be careful.
For backward compatibility, a key sequence may also be represented by a
string. In this case, it represents the key sequence(s) that would
produce that sequence of ASCII characters in a purely ASCII world. For
example, a string containing the ASCII backspace character, "\^H", would
represent two key sequences: `(control h)' and `backspace'. Binding a
command to this will actually bind both of those key sequences. Likewise
for the following pairs:
control h backspace
control i tab
control m return
control j linefeed
control [ escape
control @ control space
After binding a command to two key sequences with a form like
(define-key global-map "\^X\^I" 'command-1)
it is possible to redefine only one of those sequences like so:
(define-key global-map [(control x) (control i)] 'command-2)
(define-key global-map [(control x) tab] 'command-3)
Of course, all of this applies only when running under a window system. If
you're talking to emacs through an ASCII-only channel, you don't get any of
these features.
arguments:(keymap keys def)
Flookup-key
In keymap KEYMAP, look up key sequence KEYS. Return the definition.
nil means undefined. See doc of `define-key' for kinds of definitions
and key-sequence specifications.
Number as value means KEYS is "too long";
that is, characters in it except for the last one
fail to be a valid sequence of prefix characters in KEYMAP.
The number is how many characters at the front of KEYS
it takes to reach a non-prefix command.
arguments:(keymap keys)
Fkey-binding
Return the binding for command KEYS in current keymaps.
KEYS is a string, a vector of events, or a vector of key-description lists
as described in the documentation for the `define-key' function.
The binding is probably a symbol with a function definition.
arguments:(keys)
Fuse-global-map
Select KEYMAP as the global keymap.
arguments:(keymap)
Fuse-local-map
Select KEYMAP as the local keymap.
If KEYMAP is nil, that means no local keymap.
arguments:(keymap)
Fcurrent-local-map
Return current buffer's local keymap, or nil if it has none.
arguments:()
Fcurrent-global-map
Return the current global keymap.
arguments:()
Fmap-keymap
Apply FUNCTION to each element of KEYMAP. FUNCTION will be called with
two arguments: a key-description list, and the binding. The order in which
the elements of the keymap are passed to the function is unspecified. If
the function inserts new elements into the keymap, it may or may not
be called with them later. No element of the keymap will ever be passed to
the function more than once.
The function will not be called on elements of this keymap's parent (see the
function `keymap-parent') or upon keymaps which are contained within this
keymap (multi-character definitions). It will be called on "meta"
characters, however, since they are not really two-character sequences.
If the optional third argument SORT-FIRST is non-nil, then the elements of
the keymap will be passed to the mapper function in a canonical order.
Otherwise, they will be passed in hash (that is, random) order, which is
faster.
arguments:(function keymap &optional sort_first)
Faccessible-keymaps
Find all keymaps accessible via prefix characters from KEYMAP.
Returns a list of elements of the form (KEYS . MAP), where the sequence
KEYS starting from KEYMAP gets you to MAP. These elements are ordered
so that the KEYS increase in length. The first element is ([] . KEYMAP).
arguments:(startmap)
Fkey-description
Return a pretty description of key-sequence KEYS.
Control characters turn into "C-foo" sequences, meta into "M-foo"
spaces are put between sequence elements, etc.
arguments:(keys)
Fsingle-key-description
Return a pretty description of command character KEY.
Control characters turn into C-whatever, etc.
arguments:(key)
Ftext-char-description
Return a pretty description of file-character CHAR.
Control characters turn into "^char", etc.
arguments:(chr)
Fwhere-is-internal
Return list of keys that invoke DEFINITION in optional 2nd argument KEYMAP
or optional 4th argument GLOBAL_KEYMAP.
If KEYMAP is nil, search only GLOBAL_KEYMAP.
If GLOBAL_KEYMAP is nil, use the current global map.
If optional 3rd arg FIRSTONLY is non-nil,
return the first key sequence found, rather than a list of all possible
key sequences.
arguments:(definition &optional local_keymap firstonly global_keymap noindirect)
Fdescribe-bindings
Show a list of all defined keys, and their definitions.
The list is put in a buffer, which is displayed.
If the argument is non-null, then only the mouse bindings are displayed.
arguments:(&optional mice_only_p)
Fapropos-internal
Show all symbols whose names contain match for REGEXP.
If optional 2nd arg PRED is non-nil, (funcall PRED SYM) is done
for each symbol and a symbol is mentioned only if that returns non-nil.
Return list of symbols found.
arguments:(string &optional pred)
Vmeta-prefix-char
Meta-prefix character code. Must be an ASCII integer.
This character followed by some character `foo' turns into `Meta-foo'.
To disable the meta-prefix-char, set it to a negative number.Vkeymap-tick
Incremented for each change to any keymap.Fread-char
arguments:()
Fget-file-char
Don't use this yourself.
arguments:()
Fload
Execute a file of Lisp code named FILE.
First try FILE with `.elc' appended, then try with `.el',
then try FILE unmodified.
This function searches the directories in `load-path'.
If optional second arg MISSING-OK is non-nil,
report no error if FILE doesn't exist.
Print messages at start and end of loading unless
optional third arg NOMESSAGE is non-nil.
If optional fourth arg NOSUFFIX is non-nil, don't try adding
suffixes `.elc' or `.el' to the specified name FILE.
Return t if file exists.
arguments:(str &optional missing_ok nomessage nosuffix)
Flocate-file
Search for FILENAME through PATH-LIST, expanded by one of the optional
SUFFIXES (string of suffixes separated by ":"s), checking for access
MODE (0|1|2|4 = exists|executable|writeable|readable), default readable.
arguments:(file path &optional suff mode)
Feval-buffer
Execute BUFFER as Lisp code.
Programs can pass argument PRINTFLAG which controls printing of output:
nil means discard it; anything else is stream for print.
arguments:(bufname &optional printflag)
Feval-region
Execute the region as Lisp code.
When called from programs, expects two arguments,
giving starting and ending indices in the current buffer
of the text to be executed.
Programs can pass third argument PRINTFLAG which controls output:
nil means discard it; anything else is stream for printing it.
If there is no error, point does not move. If there is an error,
point remains at the end of the last character read from the buffer.
arguments:(b e &optional printflag)
Fread
Read one Lisp expression as text from STREAM, return as Lisp object.
If STREAM is nil, use the value of `standard-input' (which see).
STREAM or the value of `standard-input' may be:
a buffer (read from point and advance it)
a marker (read from where it points and advance it)
a function (call it with no arguments for each character,
call it with a char as argument to push a char back)
a string (takes text from string, starting at the beginning)
t (read text line using minibuffer and use it).
arguments:(&optional readcharfun)
Fread-from-string
Read one Lisp expression which is represented as text by STRING.
Returns a cons: (OBJECT-READ . FINAL-STRING-INDEX).
START and END optionally delimit a substring of STRING from which to read;
they default to 0 and (length STRING) respectively.
arguments:(string &optional start end)
Fintern
Return the canonical symbol whose name is STRING.
If there is none, one is created by this function and returned.
A second optional argument specifies the obarray to use;
it defaults to the value of `obarray'.
arguments:(str &optional obarray)
Fintern-soft
Return the canonical symbol whose name is STRING, or nil if none exists.
A second optional argument specifies the obarray to use;
it defaults to the value of `obarray'.
arguments:(str &optional obarray)
Fmapatoms
Call FUNCTION on every symbol in OBARRAY.
OBARRAY defaults to the value of `obarray'.
arguments:(function &optional obarray)
Vobarray
Symbol table for use by `intern' and `read'.
It is a vector whose length ought to be prime for best results.
The vector's contents don't make sense if examined from Lisp programs;
to find all the symbols in an obarray, use `mapatoms'.Vvalues
List of values of all expressions which were read, evaluated and printed.
Order is reverse chronological.Vstandard-input
Stream for read to get input from.
See documentation of `read' for possible values.Vload-path
*List of directories to search for files to load.
Each element is a string (directory name) or nil (try default directory).
Note that the elements of this list *may not* begin with "~", so you must
call `expand-file-name' on them before adding them to this list.
Initialized based on EMACSLOADPATH environment variable, if any,
otherwise to default specified in by file `paths.h' when Emacs was built.
If there were no paths specified in `paths.h', then emacs chooses a default
value for this variable by looking around in the file-system near the
directory in which the emacs executable resides.Vload-in-progress
Non-nil iff inside of `load'.Vafter-load-alist
An alist of expressions to be evalled when particular files are loaded.
Each element looks like (FILENAME FORMS...).
When `load' is run and the file-name argument is FILENAME,
the FORMS in the corresponding element are executed at the end of loading.
FILENAME must match exactly! Normally FILENAME is the name of a library,
with no directory specified, since that is how `load' is normally called.
An error in FORMS does not undo the load,
but does prevent execution of the rest of the FORMS.Vload-warn-when-source-newer
*Whether `load' should check whether the source is newer than the binary;
If this variable is true, then when a `.elc' file is being loaded and the
corresponding `.el' is newer, a warning message will be printed.Vload-warn-when-source-only
*Whether `load' should warn when loading a .el file instead of an .elc.
If this variable is true, then when load is called with a filename without
an extension, and the .elc version doesn't exist but the .el version does,
then a message will be printed. If an explicit extension is passed to load,
no warning will be printed.Fstart-kbd-macro
Record subsequent keyboard and menu input, defining a keyboard macro.
The commands are recorded even as they are executed.
Use \[end-kbd-macro] to finish recording and make the macro available.
Use \[name-last-kbd-macro] to give it a permanent name.
Non-nil arg (prefix arg) means append to last macro defined;
This begins by re-executing that macro as if you typed it again.
arguments:(append)
Fend-kbd-macro
Finish defining a keyboard macro.
The definition was started by \[start-kbd-macro].
The macro is now available for use via \[call-last-kbd-macro],
or it can be given a name with \[name-last-kbd-macro] and then invoked
under that name.
With numeric arg, repeat macro now that many times,
counting the definition just completed as the first repetition.
An argument of zero means repeat until error.
arguments:(&optional arg)
Fcall-last-kbd-macro
Call the last keyboard macro that you defined with \[start-kbd-macro].
A prefix argument serves as a repeat count. Zero means repeat until error.
To make a macro permanent so you can call it even after
defining others, use \[name-last-kbd-macro].
arguments:(&optional prefix)
Fexecute-kbd-macro
Execute MACRO as string of editor command characters.
If MACRO is a symbol, its function definition is used.
COUNT is a repeat count, or nil for once, or 0 for infinite loop.
arguments:(macro &optional prefixarg)
Vdefining-kbd-macro
Non-nil while a keyboard macro is being defined. Don't set this!Vexecuting-macro
Currently executing keyboard macro (a vector of events);
nil if none executing.Vexecuting-kbd-macro
Currently executing keyboard macro (a vector of events);
nil if none executing.Vlast-kbd-macro
Last kbd macro defined, as a vector of events; nil if none defined.Fmarker-buffer
Return the buffer that MARKER points into, or nil if none.
Returns nil if MARKER points into a dead buffer.
arguments:(marker)
Fmarker-position
Return the position MARKER points at, as a character number.
arguments:(marker)
Fset-marker
Position MARKER before character number NUMBER in BUFFER.
BUFFER defaults to the current buffer.
If NUMBER is nil, makes marker point nowhere.
Then it no longer slows down editing in any buffer.
If this marker was returned by (point-marker t), then changing its position
moves point. You cannot change its buffer or make it point nowhere.
Returns MARKER.
arguments:(marker pos &optional buffer)
Fcopy-marker
Return a new marker pointing at the same place as MARKER.
If argument is a number, makes a new marker pointing
at that position in the current buffer.
arguments:(marker)
Fset-menubar-dirty-flag
Tells emacs that the menubar widget has to be updated
arguments:()
Fpopup-menu
Pop up the given menu.
A menu description is a list of menu items, strings, and submenus.
The first element of a menu must be a string, which is the name of the
menu. This is the string that will be displayed in the parent menu, if
any. For toplevel menus, it is ignored. This string is not displayed
in the menu itself.
A menu item is a vector of three or four elements:
- the name of the menu item (a string);
- the `callback' of that item;
- whether this item is active (selectable);
- and an optional string to append to the name.
If the `callback' of a menu item is a symbol, then it must name a command.
It will be invoked with `call-interactively'. If it is a list, then it is
evaluated with `eval'.
The fourth element of a menu item is a convenient way of adding the name
of a command's ``argument'' to the menu, like ``Kill Buffer NAME''.
If an element of a menu is a string, then that string will be presented in
the menu as unselectable text.
If an element of a menu is a string consisting solely of hyphens, then that
item will be presented as a solid horizontal line.
If an element of a menu is a list, it is treated as a submenu. The name of
that submenu (the first element in the list) will be used as the name of the
item representing this menu on the parent.
The syntax, more precisely:
form := <something to pass to `eval'>
command := <a symbol or string, to pass to `call-interactively'>
callback := command | form
active-p := <t or nil, whether this thing is selectable>
text := <string, non selectable>
name := <string>
argument := <string>
menu-item := '[' name callback active-p [ argument ] ']'
menu := '(' name [ menu-item | menu | text ]+ ')'
arguments:(menu_desc)
Fpopup-menu-up-p
Returns T if a popup menu is up, NIL otherwise.
See popup-menu.
arguments:()
Fpopup-dialog-box
Pop up a dialog box.
A dialog box description is a list.
- The first element of the list is a string to display in the dialog box.
- The rest of the elements are descriptions of the dialog box's buttons.
Each one is a vector of three elements:
- The first element is the text of the button.
- The second element is the `callback'.
- The third element is t or nil, whether this button is selectable.
If the `callback' of a button is a symbol, then it must name a command.
It will be invoked with `call-interactively'. If it is a list, then it is
evaluated with `eval'.
One (and only one) of the buttons may be `nil'. This marker means that all
following buttons should be flushright instead of flushleft.
The syntax, more precisely:
form := <something to pass to `eval'>
command := <a symbol or string, to pass to `call-interactively'>
callback := command | form
active-p := <t or nil, whether this thing is selectable>
name := <string>
partition := 'nil'
button := '[' name callback active-p ']'
dialog := '(' name [ button ]+ [ partition [ button ]+ ] ')'
arguments:(dbox_desc)
Vcurrent-menubar
The current menubar. This may be buffer-local.
When the menubar is changed, the function `set-menubar-dirty-flag' has to
be called for the menubar to be updated on the screen. See `set-menubar'
and `set-buffer-menubar'.
A menubar is a list of menus and menu-items.
A menu is a list of menu items, strings, and submenus.
The first element of a menu must be a string, which is the name of the
menu. This is the string that will be displayed in the menubar, or in
the parent menu. This string is not displayed in the menu itself.
A menu item is a vector of three or four elements:
- the name of the menu item (a string);
- the `callback' of that item;
- whether this item is active (selectable);
- and an optional string to append to the name.
If the `callback' of a menu item is a symbol, then it must name a command.
It will be invoked with `call-interactively'. If it is a list, then it is
evaluated with `eval'.
The fourth element of a menu item is a convenient way of adding the name
of a command's ``argument'' to the menu, like ``Kill Buffer NAME''.
If an element of a menu (or menubar) is a string, then that string will be
presented in the menu (or menubar) as unselectable text.
If an element of a menu is a string consisting solely of hyphens, then that
item will be presented as a solid horizontal line.
If an element of a menu is a list, it is treated as a submenu. The name of
that submenu (the first element in the list) will be used as the name of
the item representing this menu on the parent.
If an element of a menubar is `nil', then it is used to represent the
division between the set of menubar-items which are flushleft and those
which are flushright. (Note: this isn't completely implemented yet.)
After the menubar is clicked upon, but before any menus are popped up,
the functions on the `activate-menubar-hook' are invoked to make changes
to the menus and menubar. This is intended to implement lazy alteration
of the sensitivity of menu items.
The syntax, more precisely:
form := <something to pass to `eval'>
command := <a symbol or string, to pass to `call-interactively'>
callback := command | form
active-p := <t or nil, whether this thing is selectable>
text := <string, non selectable>
name := <string>
argument := <string>
menu-item := '[' name callback active-p [ argument ] ']'
menu := '(' name [ menu-item | menu | text ]+ ')'
partition := 'nil'
menubar := '(' [ menu-item | menu | text ]* [ partition ]
[ menu-item | menu | text ]*
')'Vactivate-menubar-hook
Function or functions called before a menubar menu is pulled down.
These functions are called with no arguments, and should interrogate and
modify the value of `current-menubar' as desired.
The functions on this hook are invoked after the mouse goes down, but before
the menu is mapped, and may be used to activate, deactivate, add, or delete
items from the menus.
These functions may return the symbol `t' to assert that they have made
no changes to the menubar. If any other value is returned, the menubar is
recomputed. If `t' is returned but the menubar has been changed, then the
changes may not show up right away. Returning `nil' when the menubar has
not changed is not so bad; more computation will be done, but redisplay of
the menubar will still be performed optimally.Vmenu-no-selection-hook
Function or functions to call when a menu or dialog box is dismissed
without a selecting having been made.Vmenubar-show-keybindings
If true, the menubar will display keyboard equivalents.
If false, only the command names will be displayed.Fminibuffer-depth
Return current depth of activations of minibuffer, a nonnegative integer.
arguments:()
Fread-minibuffer-internal
Lowest-level interface to minibuffers. Don't call this.
arguments:(prompt)
Ftry-completion
Return common substring of all completions of STRING in ALIST.
Each car of each element of ALIST is tested to see if it begins with STRING.
All that match are compared together; the longest initial sequence
common to all matches is returned as a string.
If there is no match at all, nil is returned.
For an exact match, t is returned.
ALIST can be an obarray instead of an alist.
Then the print names of all symbols in the obarray are the possible matches.
ALIST can also be a function to do the completion itself.
It receives three arguments: the values STRING, PREDICATE and nil.
Whatever it returns becomes the value of `try-completion'.
If optional third argument PREDICATE is non-nil,
it is used to test each possible match.
The match is a candidate only if PREDICATE returns non-nil.
The argument given to PREDICATE is the alist element or the symbol from the obarray.
arguments:(string alist &optional pred)
Fall-completions
Search for partial matches to STRING in ALIST.
Each car of each element of ALIST is tested to see if it begins with STRING.
The value is a list of all the strings from ALIST that match.
ALIST can be an obarray instead of an alist.
Then the print names of all symbols in the obarray are the possible matches.
ALIST can also be a function to do the completion itself.
It receives three arguments: the values STRING, PREDICATE and t.
Whatever it returns becomes the value of `all-completions'.
If optional third argument PREDICATE is non-nil,
it is used to test each possible match.
The match is a candidate only if PREDICATE returns non-nil.
The argument given to PREDICATE is the alist element or
the symbol from the obarray.
arguments:(string alist &optional pred)
Vcompletion-ignore-case
Non-nil means don't consider case significant in completion.Fml-if
Mocklisp version of `if'.
arguments: (&rest args)
Fml-nargs
Number of arguments to currently executing mocklisp function.
arguments:()
Fml-arg
Argument number N to currently executing mocklisp function.
arguments:(n &optional prompt)
Fml-interactive
True if currently executing mocklisp function was called interactively.
arguments:()
Fml-provide-prefix-argument
Evaluate second argument, using first argument as prefix arg value.
arguments: (arg1 arg2 &rest args)
Fml-prefix-argument-loop
arguments: (&rest args)
Fml-substr
Return a substring of STRING, starting at index FROM and of length LENGTH.
If either FROM or LENGTH is negative, the length of STRING is added to it.
arguments:(string from to)
Finsert-string
Mocklisp-compatibility insert function.
Like the function `insert' except that any argument that is a number
is converted into a string by expressing it in decimal.
arguments: (&rest args)
Fwrite-char
Output character CHAR to stream STREAM.
STREAM defaults to the value of `standard-output' (which see).
arguments:(ch &optional printcharfun)
Fwith-output-to-temp-buffer
Bind `standard-output' to buffer BUFNAME, eval BODY, then show that buffer.
The buffer is cleared out initially, and marked as unmodified when done.
All output done by BODY is inserted in that buffer by default.
The buffer is displayed in another window, but not selected.
The value of the last form in BODY is returned.
If BODY does not finish normally, the buffer BUFNAME is not displayed.
If variable `temp-buffer-show-function' is non-nil, call it at the end
to get the buffer displayed. It gets one argument, the buffer to display.
arguments: (arg1 &rest args)
Fterpri
Output a newline to STREAM.
If STREAM is omitted or nil, the value of `standard-output' is used.
arguments:(&optional printcharfun)
Fprin1
Output the printed representation of OBJECT, any Lisp object.
Quoting characters are printed when needed to make output that `read'
can handle, whenever this is possible.
Output stream is STREAM, or value of `standard-output' (which see).
arguments:(obj &optional printcharfun)
Fprin1-to-string
Return a string containing the printed representation of OBJECT,
any Lisp object. Quoting characters are used when needed to make output
that `read' can handle, whenever this is possible, unless the optional
second argument NOESCAPE is non-nil.
arguments:(obj &optional noescape)
Fprinc
Output the printed representation of OBJECT, any Lisp object.
No quoting characters are used; no delimiters are printed around
the contents of strings.
Output stream is STREAM, or value of standard-output (which see).
arguments:(obj &optional printcharfun)
Fprint
Output the printed representation of OBJECT, with newlines around it.
Quoting characters are printed when needed to make output that `read'
can handle, whenever this is possible.
Output stream is STREAM, or value of `standard-output' (which see).
arguments:(obj &optional printcharfun)
Falternate-debugging-output
Append CHARACTER to a string.
You can call print while debugging emacs, and pass it this function
to make it write to the debugging output.
arguments:(character)
Fexternal-debugging-output
Write CHARACTER to stderr.
You can call print while debugging emacs, and pass it this function
to make it write to the debugging output.
arguments:(character)
Vstandard-output
Output stream `print' uses by default for outputting a character.
This may be any function of one argument.
It may also be a buffer (output is inserted before point)
or a marker (output is inserted and the marker is advanced)
or the symbol t (output appears in the minibuffer line).Vfloat-output-format
The format descriptor string that lisp uses to print floats.
This is a %-spec like those accepted by `printf' in C,
but with some restrictions. It must start with the two characters `%.'.
After that comes an integer precision specification,
and then a letter which controls the format.
The letters allowed are `e', `f' and `g'.
Use `e' for exponential notation "DIG.DIGITSeEXPT"
Use `f' for decimal point notation "DIGITS.DIGITS".
Use `g' to choose the shorter of those two formats for the number at hand.
The precision in any of these cases is the number of digits following
the decimal point. With `f', a precision of 0 means to omit the
decimal point. 0 is not allowed with `f' or `g'.
A value of nil means to use `%.16g'.
Regardless of the value of `float-output-format', a floating point number
will never be printed in such a way that it is ambiguous with an integer;
that is, a floating-point number will always be printed with a decimal
point and/or an exponent, even if the digits following the decimal point
are all zero. This is to preserve read-equivalence.Vprint-length
Maximum length of list to print before abbreviating.A value of nil means no limit.Vprint-level
Maximum depth of list nesting to print before abbreviating.A value of nil means no limit.Vprint-escape-newlines
Non-nil means print newlines in strings as backslash-n.Vprint-readably
If non-nil, then all objects will be printed in a readable form.
If an object has no readable representation, then an error is signalled.
When this is true, compiled-function objects will be written in #[...] form
instead of in #<byte-code [...]> form.
Do not SET this variable; bind it instead.Vprint-gensym
If non-nil, then uninterned symbols (those made with `make-symbol'
instead of `intern') will be preceeded by "#:", which tells the reader to
create a new symbol instead of interning. Beware: the #: syntax creates a
new symbol each time it is seen, so if you print an object which contains
two pointers to the same uninterned symbol, `read' will not duplicate that
structure.Fprocessp
Return t if OBJECT is a process.
arguments:(obj)
Fget-process
Return the process named NAME, or nil if there is none.
arguments:(name)
Fget-buffer-process
Return the (or, a) process associated with BUFFER.
BUFFER may be a buffer or the name of one.
arguments:(name)
Fdelete-process
Delete PROCESS: kill it and forget about it immediately.
PROCESS may be a process or the name of one, or a buffer name.
arguments:(proc)
Fprocess-status
Return the status of PROCESS: a symbol, one of these:
run -- for a process that is running.
stop -- for a process stopped but continuable.
exit -- for a process that has exited.
signal -- for a process that has got a fatal signal.
open -- for a network stream connection that is open.
closed -- for a network stream connection that is closed.
nil -- if arg is a process name and no such process exists.
arguments:(proc)
Fprocess-exit-status
Return the exit status of PROCESS or the signal number that killed it.
If PROCESS has not yet exited or died, return 0.
If PROCESS is a net connection that was closed remotely, return 256.
arguments:(proc)
Fprocess-id
Return the process id of PROCESS.
This is the pid of the Unix process which PROCESS uses or talks to.
For a network connection, this value is nil.
arguments:(proc)
Fprocess-name
Return the name of PROCESS, as a string.
This is the name of the program invoked in PROCESS,
possibly modified to make it unique among process names.
arguments:(proc)
Fprocess-command
Return the command that was executed to start PROCESS.
This is a list of strings, the first string being the program executed
and the rest of the strings being the arguments given to it.
For a non-child channel, this is nil.
arguments:(proc)
Fset-process-buffer
Set buffer associated with PROCESS to BUFFER (a buffer, or nil).
arguments:(proc buffer)
Fprocess-buffer
Return the buffer PROCESS is associated with.
Output from PROCESS is inserted in this buffer
unless PROCESS has a filter.
arguments:(proc)
Fprocess-mark
Return the marker for the end of the last output from PROCESS.
arguments:(proc)
Fset-process-filter
Give PROCESS the filter function FILTER; nil means no filter.
When a process has a filter, each time it does output
the entire string of output is passed to the filter.
The filter gets two arguments: the process and the string of output.
If the process has a filter, its buffer is not used for output.
arguments:(proc filter)
Fprocess-filter
Returns the filter function of PROCESS; nil if none.
See `set-process-filter' for more info on filter functions.
arguments:(proc)
Fset-process-sentinel
Give PROCESS the sentinel SENTINEL; nil for none.
The sentinel is called as a function when the process changes state.
It gets two arguments: the process, and a string describing the change.
arguments:(proc sentinel)
Fprocess-sentinel
Return the sentinel of PROCESS; nil if none.
See `set-process-sentinel' for more info on sentinels.
arguments:(proc)
Fprocess-kill-without-query
Say no query needed if PROCESS is running when Emacs is exited.
Optional second argument if non-nil says to require a query.
Value is t if a query was formerly required.
arguments:(proc &optional value)
Fprocess-kill-without-query-p
Return t or nil, depending on whether or not PROCESS will be killed
without query.
arguments:(proc)
Flist-processes
Display a list of all processes.
(Any processes listed as Exited or Signaled are actually eliminated
after the listing is made.)
arguments:()
Fprocess-list
Return a list of all processes.
arguments:()
Fstart-process
Start a program in a subprocess. Return the process object for it.
Args are NAME BUFFER PROGRAM &rest PROGRAM-ARGS
NAME is name for process. It is modified if necessary to make it unique.
BUFFER is the buffer or (buffer-name) to associate with the process.
Process output goes at end of that buffer, unless you specify
an output stream or filter function to handle the output.
BUFFER may be also nil, meaning that this process is not associated
with any buffer
Third arg is program file name. It is searched for as in the shell.
Remaining arguments are strings to give program as arguments.
arguments: (arg1 arg2 arg3 &rest args)
Fopen-network-stream
Open a TCP connection for a service to a host.
Returns a subprocess-object to represent the connection.
Input and output work as for subprocesses; `delete-process' closes it.
Args are NAME BUFFER HOST SERVICE.
NAME is name for process. It is modified if necessary to make it unique.
BUFFER is the buffer (or buffer-name) to associate with the process.
Process output goes at end of that buffer, unless you specify
an output stream or filter function to handle the output.
BUFFER may be also nil, meaning that this process is not associated
with any buffer
Third arg is name of the host to connect to.
Fourth arg SERVICE is name of the service desired, or an integer
specifying a port number to connect to.
arguments:(name buffer host service)
Fwaiting-for-user-input-p
Returns non-NIL if emacs is waiting for input from the user.
This is intended for use by asynchronous process output filters and sentinels.
arguments:()
Fprocess-send-region
Send current contents of region as input to PROCESS.
PROCESS may be a process name or an actual process.
Called from program, takes three arguments, PROCESS, START and END.
If the region is more than 500 characters long,
it is sent in several bunches. This may happen even for shorter regions.
Output from processes can arrive in between bunches.
arguments:(process start end)
Fprocess-send-string
Send PROCESS the contents of STRING as input.
PROCESS may be a process name or an actual process.
If STRING is more than 500 characters long,
it is sent in several bunches. This may happen even for shorter strings.
Output from processes can arrive in between bunches.
arguments:(process string)
Finterrupt-process
Interrupt process PROCESS. May be process or name of one.
Nil or no arg means current buffer's process.
Second arg CURRENT-GROUP non-nil means send signal to
the current process-group of the process's controlling terminal
rather than to the process's own process group.
If the process is a shell, this means interrupt current subjob
rather than the shell.
arguments:(&optional process current_group)
Fkill-process
Kill process PROCESS. May be process or name of one.
See function `interrupt-process' for more details on usage.
arguments:(&optional process current_group)
Fquit-process
Send QUIT signal to process PROCESS. May be process or name of one.
See function `interrupt-process' for more details on usage.
arguments:(&optional process current_group)
Fstop-process
Stop process PROCESS. May be process or name of one.
See function `interrupt-process' for more details on usage.
arguments:(&optional process current_group)
Fcontinue-process
Continue process PROCESS. May be process or name of one.
See function `interrupt-process' for more details on usage.
arguments:(&optional process current_group)
Fsignal-process
Send the process with number PID the signal with code CODE.
Both PID and CODE are integers.
arguments:(pid sig)
Fprocess-send-eof
Make PROCESS see end-of-file in its input.
Eof comes after any text already sent to it.
nil or no arg means current buffer's process.
arguments:(&optional process)
Fprocess-connection
Return the connection type of `PROCESS'. This can be nil (pipe),
t or pty (pty) or stream (socket connection).
arguments:(&optional process)
Vdelete-exited-processes
*Non-nil means delete processes immediately when they exit.
nil means don't delete them until `list-processes' is run.Vprocess-connection-type
Control type of device used to communicate with subprocesses.
Values are nil to use a pipe, and t or 'pty for a pty. Note that if
pty's are not available, this variable will be ignored. The value takes
effect when `start-process' is called.Fscreenp
Return non-nil if OBJECT is a screen.
Value is t for a termcap screen (a character-only terminal),
`x' for an Emacs screen that is really an X window.
arguments:(screen)
Fselect-screen
Select the screen S.
S's selected window becomes the selected window.
arguments:(screen)
Fselected-screen
Return the screen that is now selected.
arguments:()
Fwindow-screen
Return the screen that window WINDOW is on.
arguments:(window)
Fscreen-root-window
Returns the root-window of SCREEN.
arguments:(&optional screen)
Fscreen-selected-window
Return the selected window of screen SCREEN.
arguments:(&optional screen)
Fscreen-list
Return a list of all screens.
arguments:()
Fnext-screen
Return the next screen in the screen list after SCREEN.
If MINISCREEN is non-nil, include the global-minibuffer-screen if it
has its own screen.
If VISIBLE-ONLY-P is non-nil, then cycle through the visible screens,
instead of all screens.
arguments:(&optional screen miniscreen visible_only_p)
Fprevious-screen
Return the previous screen in the screen list after SCREEN.
If MINISCREEN is non-nil, include the global-minibuffer-screen if it
has its own screen.
If VISIBLE-ONLY-P is non-nil, then cycle through the visible screens,
instead of all screens.
arguments:(&optional screen miniscreen visible_only_p)
Fdelete-screen
Delete SCREEN, permanently eliminating it from use.
Default is current screen.
arguments:(&optional screen)
Fread-mouse-position
Return a cons (x . y) which represents the position of the mouse.
arguments:(screen)
Fset-mouse-position
Move the mouse pointer to the center of character cell (X,Y) in SCREEN.
arguments:(screen x y)
Fscreen-configuration
Return object describing current screen configuration.
The screen configuration is the current mouse position and selected screen.
This object can be given to `restore-screen-configuration'
to restore this screen configuration.
arguments:()
Frestore-screen-configuration
Restores screen configuration CONFIGURATION.
arguments:(config)
Fmake-screen-visible
Make the screen SCREEN visible (assuming it is an X-window).
Also raises the screen so that nothing obscures it.
arguments:(screen)
Fmake-screen-invisible
Unconditionally removes screen from the display (assuming it is an X-window).
If what you want to do is iconify the screen (if the window manager uses
icons) then you should call `iconify-screen' instead.
arguments:(screen)
Ficonify-screen
Make the screen SCREEN into an icon, if the window manager supports icons.
arguments:(screen)
Fdeiconify-screen
Open (de-iconify) the iconified screen SCREEN.
arguments:(screen)
Fscreen-visible-p
Return t if SCREEN is now "visible" (actually in use for display).
A screen that is not "visible" is not updated and, if it works through
a window system, it may not show at all.
Return the symbol `icon' if window is visible only as an icon.
arguments:(screen)
Fvisible-screen-list
Return a list of all screens now "visible" (being updated).
arguments:()
Fscreen-parameters
Return the parameters-alist of screen SCREEN.
It is a list of elements of the form (PARM . VALUE), where PARM is a symbol.
The meaningful PARMs depend on the kind of screen.
arguments:(&optional screen)
Fmodify-screen-parameters
Modify the parameters of screen SCREEN according to ALIST.
ALIST is an alist of parameters to change and their new values.
Each element of ALIST has the form (PARM . VALUE), where PARM is a symbol.
The meaningful PARMs depend on the kind of screen; undefined PARMs are ignored.
arguments:(screen alist)
Fscreen-height
Return number of lines available for display on SCREEN.
arguments:(&optional screen)
Fscreen-width
Return number of columns available for display on SCREEN.
arguments:(&optional screen)
Fscreen-name
Returns the name of SCREEN (defaulting to the selected screen).
This is not the same as the `title' of the screen.
arguments:(&optional screen)
Fscreen-totally-visible-p
Return T if screen is not obscured by any other X windows, NIL otherwise
arguments:(&optional screen)
Fset-screen-height
Specify that the screen SCREEN has LINES lines.
Optional third arg non-nil means that redisplay should use LINES lines
but that the idea of the actual height of the screen should not be changed.
arguments:(screen rows &optional pretend)
Fset-screen-width
Specify that the screen SCREEN has COLS columns.
Optional third arg non-nil means that redisplay should use COLS columns
but that the idea of the actual width of the screen should not be changed.
arguments:(screen cols &optional pretend)
Fset-screen-size
Sets size of SCREEN to COLS by ROWS.
Optional fourth arg non-nil means that redisplay should use COLS by ROWS
but that the idea oft eh acrual size of the screen should not be changed.
arguments:(screen cols rows &optional pretend)
Fset-screen-position
Sets position of SCREEN in pixels to XOFFSET by YOFFSET.
arguments:(screen xoffset yoffset)
Fraise-screen
Make the window of SCREEN be the uppermost one (fully visible).
arguments:(screen)
Flower-screen
Make the window of SCREEN be the bottommost one.
arguments:(screen)
Fcoordinates-in-window-p
Return non-nil if COORDINATES are in WINDOW.
COORDINATES is a cons of the form (X Y), X and Y being screen-relative.
If COORDINATES are in the text portion of WINDOW, the coordinates relative
to the window are returned. If they are in the modeline of WINDOW, t is
returned.
arguments:(coordinates window)
Flocate-window-from-coordinates
Return window on SCREEN containing position COORDINATES.
COORDINATES is a list (SCREEN-X SCREEN-Y) of coordinates
which are relative to 0,0 at the top left corner of the screen.
arguments:(screen coordinates)
Vterminal-screen
The initial screen-object, which represents Emacs's stdout.Vglobal-minibuffer-screen
A screen-object holding the default minibuffer for minibufferless screens.
When you create a minibufferless screen, by default it will use the
minibuffer of this screen. It is up to you to create a suitable screen
and store it in this variable.Vallow-deletion-of-last-visible-screen
*If nil, the last visible screen may not be deleted by `delete-window'
You can never delete the last screen, but setting this to t will allow you
to delete the last non-iconified screen.Vcreate-screen-hook
Function or functions of one argument, called with each newly-created screen.Vmouse-enter-screen-hook
Function or functions to call when mouse enters a screen. One arg, the screen.
Be careful not to make assumptions about the window manger's focus model.
In most cases, the `deselect-screen-hook' is more appropriate.Vmouse-leave-screen-hook
Function or functions to call when mouse leaves screen. One arg, the screen.
Be careful not to make assumptions about the window manger's focus model.
In most cases, the `select-screen-hook' is more appropriate.Vmap-screen-hook
Function or functions to call when screen is mapped.
One arg, the screen.Vunmap-screen-hook
Function or functions to call when screen is unmapped.
One arg, the screen.Vmouse-motion-handler
Handler for motion events. One arg, the event.
For most applications, you should use `mode-motion-hook' instead of this.Vmouse-grabbed-buffer
A buffer which should be consulted first for all mouse activity.
When a mouse-clicked it processed, it will first be looked up in the
local-map of this buffer, and then through the normal mechanism if there
is no binding for that click. This buffer's value of `mode-motion-hook'
will be consulted instead of the `mode-motion-hook' of the buffer of the
window under the mouse. You should *bind* this, not set it.Flooking-at
t if text after point matches regular expression PAT.
arguments:(string)
Fstring-match
Return index of start of first match for REGEXP in STRING, or nil.
If third arg START is non-nil, start search at that index in STRING.
For index of first char beyond the match, do (match-end 0).
match-end and match-beginning also give indices of substrings
matched by parenthesis constructs in the pattern.
arguments:(regexp string &optional start)
Fskip-chars-forward
Move point forward, stopping before a char not in CHARS, or at position LIM.
CHARS is like the inside of a [...] in a regular expression
except that ] is never special and \ quotes ^, - or \.
Thus, with arg "a-zA-Z", this skips letters stopping before first nonletter.
With arg "^a-zA-Z", skips nonletters stopping before first letter.
arguments:(string &optional lim)
Fskip-chars-backward
Move point backward, stopping after a char not in CHARS, or at position LIM.
See skip-chars-forward for details.
arguments:(string &optional lim)
Fsearch-backward
Search backward from point for STRING.
Set point to the beginning of the occurrence found, and return t.
An optional second argument bounds the search; it is a buffer position.
The match found must not extend before that position.
Optional third argument, if t, means if fail just return nil (no error).
If not nil and not t, position at limit of search and return nil.
Optional fourth argument is repeat count--search for successive occurrences.
arguments:(string &optional bound noerror count)
Fsearch-forward
Search forward from point for STRING.
Set point to the end of the occurrence found, and return t.
An optional second argument bounds the search; it is a buffer position.
The match found must not extend after that position.
Optional third argument, if t, means if fail just return nil (no error).
If not nil and not t, move to limit of search and return nil.
Optional fourth argument is repeat count--search for successive occurrences.
arguments:(string &optional bound noerror count)
Fword-search-backward
Search backward from point for STRING, ignoring differences in punctuation.
Set point to the beginning of the occurrence found, and return t.
An optional second argument bounds the search; it is a buffer position.
The match found must not extend before that position.
Optional third argument, if t, means if fail just return nil (no error).
If not nil and not t, move to limit of search and return nil.
Optional fourth argument is repeat count--search for successive occurrences.
arguments:(string &optional bound noerror count)
Fword-search-forward
Search forward from point for STRING, ignoring differences in punctuation.
Set point to the end of the occurrence found, and return t.
An optional second argument bounds the search; it is a buffer position.
The match found must not extend after that position.
Optional third argument, if t, means if fail just return nil (no error).
If not nil and not t, move to limit of search and return nil.
Optional fourth argument is repeat count--search for successive occurrences.
arguments:(string &optional bound noerror count)
Fre-search-backward
Search backward from point for match for regular expression REGEXP.
Set point to the beginning of the match, and return t.
The match found is the one starting last in the buffer
and yet ending before the place the origin of the search.
An optional second argument bounds the search; it is a buffer position.
The match found must start at or after that position.
Optional third argument, if t, means if fail just return nil (no error).
If not nil and not t, move to limit of search and return nil.
Optional fourth argument is repeat count--search for successive occurrences.
See also the functions match-beginning and match-end and replace-match.
arguments:(string &optional bound noerror count)
Fre-search-forward
Search forward from point for regular expression REGEXP.
Set point to the end of the occurrence found, and return t.
An optional second argument bounds the search; it is a buffer position.
The match found must not extend after that position.
Optional third argument, if t, means if fail just return nil (no error).
If not nil and not t, move to limit of search and return nil.
Optional fourth argument is repeat count--search for successive occurrences.
See also the functions match-beginning and match-end and replace-match.
arguments:(string &optional bound noerror count)
Freplace-match
Replace text matched by last search with NEWTEXT.
If second arg FIXEDCASE is non-nil, do not alter case of replacement text.
Otherwise convert to all caps or cap initials, like replaced text.
If third arg LITERAL is non-nil, insert NEWTEXT literally.
Otherwise treat \ as special:
\& in NEWTEXT means substitute original matched text,
\N means substitute match for \(...\) number N,
\\ means insert one \.
Leaves point at end of replacement text.
arguments:(string &optional fixedcase literal)
Fmatch-beginning
Return the character number of start of text matched by last regexp searched for.
ARG, a number, specifies which parenthesized expression in the last regexp.
Value is nil if ARGth pair didn't match, or there were less than ARG pairs.
Zero means the entire text matched by the whole regexp.
arguments:(num)
Fmatch-end
Return the character number of end of text matched by last regexp searched for.
ARG, a number, specifies which parenthesized expression in the last regexp.
Value is nil if ARGth pair didn't match, or there were less than ARG pairs.
Zero means the entire text matched by the whole regexp.
arguments:(num)
Fmatch-data
Return list containing all info on what the last search matched.
Element 2N is (match-beginning N); element 2N + 1 is (match-end N).
All the elements are normally markers, or nil if the Nth pair didn't match.
0 is also possible, when matching was done with `string-match',
if a match began at index 0 in the string.
arguments:()
Fstore-match-data
Set internal data on last search match from elements of LIST.
LIST should have been created by calling match-data previously.
arguments:(list)
Fregexp-quote
Return a regexp string which matches exactly STRING and nothing else.
arguments:(str)
Fsyntax-table-p
Return t if ARG is a syntax table.
Any vector of 256 elements will do.
arguments:(obj)
Fsyntax-table
Return the current syntax table.
This is the one specified by the current buffer.
arguments:()
Fstandard-syntax-table
Return the standard syntax table.
This is the one used for new buffers.
arguments:()
Fcopy-syntax-table
Construct a new syntax table and return it.
It is a copy of the TABLE, which defaults to the standard syntax table.
arguments:(&optional table)
Fset-syntax-table
Select a new syntax table for the current buffer.
One argument, a syntax table.
arguments:(table)
Fchar-syntax
Return the syntax code of CHAR, described by a character.
For example, if CHAR is a word constituent, the character `?w' is returned.
The characters that correspond to various syntax codes
are listed in the documentation of `modify-syntax-entry'.
arguments:(ch)
Fmodify-syntax-entry
Set syntax for character CHAR according to string S.
The syntax is changed only for table TABLE, which defaults to
the current buffer's syntax table.
The first character of S should be one of the following:
Space whitespace syntax. w word constituent.
_ symbol constituent. . punctuation.
( open-parenthesis. ) close-parenthesis.
" string quote. \ character-quote.
$ paired delimiter. ' expression quote or prefix operator.
< comment starter. > comment ender.
Only single-character comment start and end sequences are represented thus.
Two-character sequences are represented as described below.
The second character of S is the matching parenthesis,
used only if the first character is `(' or `)'.
Any additional characters are flags.
Defined flags are the characters 1, 2, 3, 4, 5, 6, 7, 8, p, a, and b.
1 means C is the first of a two-char comment start sequence of style a.
2 means C is the second character of such a sequence.
3 means C is the first of a two-char comment end sequence of style a.
4 means C is the second character of such a sequence.
5 means C is the first of a two-char comment start sequence of style b.
6 means C is the second character of such a sequence.
7 means C is the first of a two-char comment end sequence of style b.
8 means C is the second character of such a sequence.
p means C is a prefix character for `backward-prefix-chars';
such characters are treated as whitespace when they occur
between expressions.
a means C is comment starter or comment ender for comment style a (default)
b means C is comment starter or comment ender for comment style b.
arguments:(c newentry syntax_table)
Fdescribe-syntax
Describe the syntax specifications in the syntax table.
The descriptions are inserted in a buffer, which is then displayed.
arguments:()
Fforward-word
Move point forward ARG words (backward if ARG is negative).
Normally returns t.
If an edge of the buffer is reached, point is left there
and nil is returned.
arguments:(count)
Fbackward-syntactic-ws
Move point backward over all syntactic whitespace.
This includes all chars with "whitespace" syntax (Space), and, if
parse-sexp-ignore-comments is non-nil, all characters within comments.
arguments:()
Fforward-syntactic-ws
Move point forward over all syntactic whitespace.
This includes all chars with "whitespace" syntax (Space), and, if
parse-sexp-ignore-comments is non-nil, all characters within comments.
arguments:()
Fscan-lists
Scan from character number FROM by COUNT lists.
Returns the character number of the position thus found.
If DEPTH is nonzero, paren depth begins counting from that value,
only places where the depth in parentheses becomes zero
are candidates for stopping; COUNT such places are counted.
Thus, a positive value for DEPTH means go out levels.
Comments are ignored if `parse-sexp-ignore-comments' is non-nil.
If the beginning or end of (the accessible part of) the buffer is reached
and the depth is wrong, an error is signaled.
If the depth is right but the count is not used up, nil is returned.
arguments:(from count depth)
Fscan-sexps
Scan from character number FROM by COUNT balanced expressions.
If COUNT is negative, scan backwards.
Returns the character number of the position thus found.
Comments are ignored if `parse-sexp-ignore-comments' is non-nil.
If the beginning or end of (the accessible part of) the buffer is reached
in the middle of a parenthetical grouping, an error is signaled.
If the beginning or end is reached between groupings
but before count is used up, nil is returned.
arguments:(from count)
Fbackward-prefix-chars
Move point backward over any number of chars with prefix syntax.
This includes chars with "quote" or "prefix" syntax (' or p).
arguments:()
Fparse-partial-sexp
Parse Lisp syntax starting at FROM until TO; return status of parse at TO.
Parsing stops at TO or when certain criteria are met;
point is set to where parsing stops.
If fifth arg STATE is omitted or nil,
parsing assumes that FROM is the beginning of a function.
Value is a list of eight elements describing final state of parsing:
1. depth in parens.
2. character address of start of innermost containing list; nil if none.
3. character address of start of last complete sexp terminated.
4. non-nil if inside a string.
(it is the character that will terminate the string.)
5. t if inside a comment.
6. t if following a quote character.
7. the minimum paren-depth encountered during this scan.
8. nil if in comment style a, or not in a comment; t if in comment style b
If third arg TARGETDEPTH is non-nil, parsing stops if the depth
in parentheses becomes equal to TARGETDEPTH.
Fourth arg STOPBEFORE non-nil means stop when come to
any character that starts a sexp.
Fifth arg STATE is a seven-list like what this function returns.
It is used to initialize the state of the parse.
arguments:(from to &optional targetdepth stopbefore oldstate)
Vparse-sexp-ignore-comments
Non-nil means `forward-sexp', etc., should treat comments as whitespace.Vwords-include-escapes
Non-nil means `forward-word', etc., should treat escape chars part of words.Fundo-boundary
Mark a boundary between units of undo.
An undo command will stop at this point,
but another undo command will undo to the previous boundary.
arguments:()
Fprimitive-undo
Undo N records from the front of the list LIST.
Return what remains of the list.
arguments:(count list)
V inside-undo
internal variable used to control undoFwindowp
Returns t if OBJ is a window.
arguments:(obj)
Fselected-window
Return the window that the cursor now appears in and commands apply to.
arguments:()
Fminibuffer-window
Return the window used now for minibuffers.
arguments:()
Fwindow-minibuffer-p
Returns non-nil if WINDOW is a minibuffer window.
arguments:(window)
Fpos-visible-in-window-p
Return t if position POS is currently on the screen in WINDOW.
Returns nil if that position is scrolled vertically out of view.
POS defaults to point; WINDOW, to the selected window.
arguments:(&optional pos window)
Fwindow-buffer
Return the buffer that WINDOW is displaying.
arguments:(&optional window)
Fwindow-height
Return the number of lines in WINDOW (including its mode line).
arguments:(&optional window)
Fwindow-width
Return the number of columns in WINDOW.
arguments:(&optional window)
Fwindow-hscroll
Return the number of columns by which WINDOW is scrolled from left margin.
arguments:(&optional window)
Fset-window-hscroll
Set number of columns WINDOW is scrolled from left margin to NCOL.
NCOL should be zero or positive.
arguments:(window ncol)
Fwindow-edges
Return a list of the edge coordinates of WINDOW.
(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of screen.
RIGHT is one more than the rightmost column used by WINDOW,
and BOTTOM is one more than the bottommost row used by WINDOW
and its mode-line.
arguments:(&optional window)
Fwindow-point
Return current value of point in WINDOW.
For a nonselected window, this is the value point would have
if that window were selected.
Note that, when WINDOW is the selected window and its buffer
is also currently selected, the value returned is the same as (point).
It would be more strictly correct to return the `top-level' value
of point, outside of any save-excursion forms.
But that is hard to define.
arguments:(&optional window)
Fwindow-start
Return position at which display currently starts in WINDOW.
arguments:(&optional window)
Fwindow-end
Return position at which display currently ends in WINDOW.
arguments:(&optional window)
Fset-window-point
Make point value in WINDOW be at position POS in WINDOW's buffer.
arguments:(window pos)
Fset-window-start
Make display in WINDOW start at position POS in WINDOW's buffer.
Optional third arg NOFORCE non-nil inhibits next redisplay
from overriding motion of point in order to display at this exact start.
arguments:(window pos &optional noforce)
Fwindow-dedicated-p
Return WINDOW's dedicated object, usually t or nil.
See also `set-window-buffer-dedicated'.
arguments:(window)
Fset-window-buffer-dedicated
Make WINDOW display BUFFER and be dedicated to that buffer.
Then Emacs will not automatically change which buffer appears in WINDOW.
If BUFFER is nil, make WINDOW not be dedicated (but don't change which
buffer appears in it currently).
arguments:(window arg)
Fwindow-display-table
Return the display-table that WINDOW is using.
arguments:(&optional window)
Fset-window-display-table
Set WINDOW's display-table to TABLE.
arguments:(window table)
Fdelete-window
Remove WINDOW from the display. Default is selected window.
If window is the only one on the screen, the screen is destroyed.
arguments:(&optional window)
Fnext-window
Return next window after WINDOW in canonical ordering of windows.
Optional second arg MINIBUF t means count the minibuffer window
even if not active. If MINIBUF is neither t nor nil it means
not to count the minibuffer even if it is active.
Optional third arg ALL-SCREENS t means include all windows in all visible
screens; otherwise cycle within the selected screen, with the exception that
if a global minibuffer screen is in use, all screens are used.
Optional fourth argument INVISIBLE-TOO t means also visit invisible screens.
arguments:(&optional window mini all_screens invisible_too)
Fprevious-window
Return previous window before WINDOW in canonical ordering of windows.
Optional second arg MINIBUF t means count the minibuffer window
even if not active. If MINIBUF is neither t nor nil it means
not to count the minibuffer even if it is active.
Optional third arg ALL-SCREENS t means include all windows in all visible
screens; otherwise cycle within the selected screen, with the exception
that if a global minibuffer screen is in use, all visible screens are used.
If optional fourth argument INVISIBLE-TOO is t also visit invisible screens.
arguments:(&optional window mini all_screens invisible_too)
Fother-window
Select the ARG'th different window on this screen.
All windows on current screen are arranged in a cyclic order.
This command selects the window ARG steps away in that order.
A negative ARG moves in the opposite order. If the optional second
argument ALL_SCREENS is non-nil, cycle through all visible screens.
If optional third argument INVISIBLE-TOO is t also search invisible screens.
arguments:(n &optional all_screens invisible_too)
Fget-lru-window
Return the window least recently selected or used for display.
If optional argument SCREENS is non-nil, search only that screen.
arguments:(&optional screens)
Fget-largest-window
Return the window largest in area. If optional argument SCREENS
is non-nil, search only that screen.
arguments:(&optional screens)
Fget-buffer-window
Return a window currently displaying BUFFER, or nil if none.
Only the selected screen is searched; if the optional second argument
SCREEN is non-nil, then that screen is searched instead. If SCREEN is t,
then all visible screens are searched. If FORCE is t invisible screens
are searched too.
arguments:(buffer &optional screen force)
Fdelete-other-windows
Make WINDOW (or the selected window) fill its screen.
arguments:(&optional window)
Fdelete-windows-on
Delete all windows showing BUFFER.
arguments:(buffer)
Freplace-buffer-in-windows
Replace BUFFER with some other buffer in all windows showing it.
arguments:(buffer)
Fset-window-buffer
Make WINDOW display BUFFER as its contents.
BUFFER can be a buffer or buffer name.
arguments:(window buffer)
Fselect-window
Select WINDOW. Most editing will apply to WINDOW's buffer.
The main editor command loop selects the buffer of the selected window
before each command.
arguments:(window)
Fdisplay-buffer
Make BUFFER appear in some window on the current screen, but don't select it.
BUFFER can be a buffer or a buffer name.
If BUFFER is shown already in some window in the current screen, just uses
that one, unless the window is the selected window and NOT_THIS_WINDOW_P
is non-nil.
If ON_SCREEN is non-nil, display on that screen instead of the current
screen (or the dedicated screen).
If BUFFER has a dedicated screen, display on that screen instead of the
current screen, unless ON_SCREEN was specified.
If pop-up-windows is non-nil, and the buffer is not visible in some window
on the target screen, then windows will be split (a new window will be
created) if there is room. Otherwise, the least-recently-used window will
be reused.
Returns the window displaying BUFFER.
arguments:(buffer &optional not_this_window_p on_screen)
Fsplit-window
Split WINDOW, putting SIZE lines in the first of the pair.
WINDOW defaults to selected one and SIZE to half its size.
If optional third arg HOR-FLAG is non-nil, split side by side
and put SIZE columns in the first of the pair.
arguments:(&optional window chsize horflag)
Fenlarge-window
Make current window ARG lines bigger.
From program, optional second arg non-nil means grow sideways ARG columns.
arguments:(n &optional side)
Fshrink-window
Make current window ARG lines smaller.
From program, optional second arg non-nil means shrink sideways ARG columns.
arguments:(n &optional side)
Fscroll-up
Scroll text of current window upward ARG lines; or near full screen if no ARG.
A near full screen is `next-screen-context-lines' less than a full screen.
When calling from a program, supply a number as argument or nil.
arguments:(&optional n)
Fscroll-down
Scroll text of current window downward ARG lines; or near full screen if no ARG.
A near full screen is `next-screen-context-lines' less than a full screen.
When calling from a program, supply a number as argument or nil.
arguments:(&optional n)
Fscroll-other-window
Scroll text of next window upward ARG lines; or near full screen if no ARG.
The next window is the one below the current one; or the one at the top
if the current one is at the bottom.
When calling from a program, supply a number as argument or nil.
If in the minibuffer, `minibuf-scroll-window' if non-nil
specifies the window to scroll.
If `other-window-scroll-buffer' is non-nil, scroll the window
showing that buffer, popping the buffer up if necessary.
arguments:(&optional n)
Fscroll-left
Scroll selected window display ARG columns left.
Default for ARG is window width minus 2.
arguments:(arg)
Fscroll-right
Scroll selected window display ARG columns right.
Default for ARG is window width minus 2.
arguments:(arg)
Frecenter
Center point in window and redisplay screen. With ARG, put point on line ARG.
The desired position of point is always relative to the current window.
Just C-u as prefix means put point in the center of the screen.
No arg (i.e., it is nil) erases the entire screen and then
redraws with point in the center.
arguments:(&optional n)
Fmove-to-window-line
Position point relative to window.
With no argument, position text at center of window.
An argument specifies screen line; zero means top of window,
negative means relative to bottom of window.
arguments:(arg)
Fset-window-configuration
Set the configuration of windows and buffers as specified by CONFIGURATION.
CONFIGURATION must be a value previously returned
by `current-window-configuration' (which see).
arguments:(arg)
Fcurrent-window-configuration
Return an object representing Emacs' current window configuration.
This describes the number of windows, their sizes and current buffers,
and for each displayed buffer, where display starts, and the positions of
point and mark. An exception is made for point in the current buffer:
its value is -not- saved.
arguments:()
Fsave-window-excursion
Execute body, preserving window sizes and contents.
Restores which buffer appears in which window, where display starts,
as well as the current buffer.
Does not restore the value of point in current buffer.
arguments: (&rest args)
Vtemp-buffer-show-function
Non-nil means call as function to display a help buffer.
Used by `with-output-to-temp-buffer'.Vdisplay-buffer-function
If non-nil, function to call to handle `display-buffer'.
It will receive three args, the same args as display-buffer.Vpre-display-buffer-function
If non-nil, function that will be called from `display-buffer' as the
first action. It will receive three args, the same arguments as
`display-buffer' -- the buffer, a flag which if non-nil means that the
currently selected window is not acceptable, and a screen to use (or nil,
meaning unspecified.) This function may be used to select an appropriate
screen for the buffer, for example. See also the variable
`display-buffer-function', which may be used to completely replace
display-buffer.Vminibuffer-scroll-window
Non-nil means it is the window that C-M-v in minibuffer should scroll.Vother-window-scroll-buffer
If non-nil, this is a buffer and \[scroll-other-window] should scroll its window.Vpop-up-windows
*Non-nil means display-buffer should make new windows.Vnext-screen-context-lines
*Number of lines of continuity when scrolling by screenfuls.Vsplit-height-threshold
*display-buffer would prefer to split the largest window if this large.
If there is only one window, it is split regardless of this value.Vwindow-min-height
*Delete any window less than this tall (including its mode line).Vwindow-min-width
*Delete any window less than this wide.Fredraw-screen
Clear screen SCREEN and output again what is supposed to appear on it.
arguments:(screen)
Fredraw-display
Redraw all screens marked as having their images garbled.
arguments:()
Fredraw-display
Clear the screen and output again what is supposed to appear on it.
arguments:()
Vglobal-mode-string
String displayed by mode-line-format's "%m" specification.Voverlay-arrow-position
Marker for where to display an arrow on top of the buffer text.
This must be the beginning of a line in order to work.
See also `overlay-arrow-string'.Voverlay-arrow-string
String to display as an arrow. See also `overlay-arrow-position'.Vscroll-step
*The number of lines to try scrolling a window by when point moves out.
If that fails to bring point back on screen, point is centered instead.
If this is zero, point is always centered after it moves off screen.Vtruncate-partial-width-windows
*Non-nil means truncate lines in all windows less than full screen wide.Vmode-line-inverse-video
*Non-nil means use inverse video for the mode line.Vscreen-title-format
Controls the title of the X window corresponding to the selected screen.
This is the same format as `mode-line-format'.Vscreen-icon-title-format
Controls the title of the icon corresponding to the selected screen.
See also the variable `screen-title-format'Fenergize-toggle-psheet
arguments:()
Fx-create-screen
Make a new X window, which is considered a "screen" in Emacs terms.
Return an Emacs screen object representing the X window.
ALIST is an alist of screen parameters.
The value of `x-screen-defaults' is an additional alist
of default parameters which apply when not overridden by ALIST.
Optional second argument is the numerical ID of the X window to use for this
screen (in order to run Emacs on a window created by some other program).
Since this ID number is an unsigned long, you must pass it as a string.
It may be a string of decimal numbers, or a string of hex numbers beginning
with "0x".
arguments:(parms &optional lisp_window_id)
Fx-focus-screen
Obsolete function. Superceded by select-screen
arguments:(focus_p &optional screen)
Fx-show-lineinfo-column
Make the current emacs screen have a lineinfo column.
arguments:(&optional screen)
Fx-hide-lineinfo-column
Make the given emacs screen not have a lineinfo column.
arguments:(&optional screen)
Fx-display-visual-class
Returns the visual class of the display `screen' is on.
The returned value will be one of the symbols StaticGray, GrayScale,
StaticColor, PseudoColor, TrueColor, or DirectColor.
arguments:(&optional screen)
Fx-color-display-p
Returns t if the X display of the given screen supports color.
arguments:(&optional screen)
Fx-pixel-width
Returns the width in pixels of the given screen.
arguments:(&optional screen)
Fx-pixel-height
Returns the height in pixels of the given screen.
arguments:(&optional screen)
Fx-display-pixel-width
Returns the width in pixels of the display `screen' is on.
arguments:(&optional screen)
Fx-display-pixel-height
Returns the height in pixels of the display `screen' is on.
arguments:(&optional screen)
Fx-display-planes
Returns the number of bitplanes of the display `screen' is on.
arguments:(&optional screen)
Fx-display-color-cells
Returns the number of color cells of the display `screen' is on.
arguments:(&optional screen)
Fx-server-vendor
Returns the vendor ID string of the X server `screen' is on.
arguments:(&optional screen)
Fx-server-version
Returns the version numbers of the X server `screen' is on.
The returned value is a list of three integers: the major and minor
version numbers of the X Protocol in use, and the vendor-specific release
number. See also `x-server-vendor'.
arguments:(&optional screen)
Fx-set-screen-icon-pixmap
Set the icon-pixmap of the given screen.
This should be the name of a bitmap file, or a bitmap description list
of the form (width height "bitmap-data").
If the optional third argument is specified, it is the bitmap to use for
the icon-pixmap-mask (not all window managers obey this.)
Warning: when you call this function, the pixmap of the previous icon
of this screen (if any) is currently not freed.
arguments:(screen pixmap &optional mask)
Fx-grab-pointer
Grab the pointer and restrict it to its current window. If optional
SHAPE is non-nil, change the pointer shape to that. If second optional
argument MOUSE-ONLY is non-nil, ignore keyboard events during the grab.
arguments:(&optional shape ignore_keyboard)
Fx-ungrab-pointer
Release the pointer.
arguments:()
Fx-EnterNotify-internal
hands off
arguments:(screen)
Fx-LeaveNotify-internal
hands off
arguments:(screen)
Fx-FocusIn-internal
hands off
arguments:(screen)
Fx-FocusOut-internal
hands off
arguments:(screen)
Fx-VisibilityNotify-internal
hands off
arguments:(screen)
Fx-non-VisibilityNotify-internal
hands off
arguments:(screen)
Fx-MapNotify-internal
hands off
arguments:(screen)
Fx-UnmapNotify-internal
hands off
arguments:(screen)
Fx-rebind-key
Rebind X keysym KEYSYM, with MODIFIERS, to generate NEWSTRING.
KEYSYM is a string which conforms to the X keysym definitions found
in X11/keysymdef.h, sans the initial XK_. MODIFIERS is nil or a
list of strings specifying modifier keys such as Control_L, which must
also be depressed for NEWSTRING to appear.
arguments:(x_keysym modifiers newstring)
Fx-rebind-keys
Rebind KEYCODE to list of strings STRINGS.
STRINGS should be a list of 16 elements, one for each shift combination.
nil as element means don't change.
See the documentation of `x-rebind-key' for more information.
arguments:(keycode strings)
Fx-get-resource
Retrieve an X resource from the resource manager.
The first arg is the name of the resource to retrieve, such as "font".
The second arg is the class of the resource to retrieve, like "Font".
The third arg should be one of the symbols string, integer, or boolean,
specifying the type of object that the database is searched for.
The fourth arg is the screen to search for the resources on, defaulting
to the selected screen.
The call
(x-get-resource "font" "Font" 'string)
is an interface to the C call
XrmGetResource (db, "emacs.this_screen_name.font",
"Emacs.EmacsScreen.Font",
"String");
Therefore if you want to retrieve a deeper resource, for example,
"Emacs.foo.foreground", you need to specify the same number of links
in the class path:
(x-get-resource "foo.foreground" "Thing.Foreground" 'string)
which is equivalent to
XrmGetResource (db, "emacs.screen_name.foo.foreground",
"Emacs.EmacsScreen.Thing.Foreground",
"String");
The returned value of this function is nil if the queried resource is not
found. If the third arg is `string', a string is returned, and if it is
`integer', an integer is returned. If the third arg is `boolean', then the
returned value is the list (t) for true, (nil) for false, and is nil to
mean ``unspecified.''
arguments:(name class type &optional screen)
Fx-valid-color-name-p
Returns true if COLOR names a color that X knows about.
Valid color names are listed in the file /usr/lib/X11/rgb.txt, or
whatever the equivalent is on your system.
arguments:(color &optional screen)
Fx-valid-keysym-name-p
Returns true if KEYSYM names a keysym that the X library knows about.
Valid keysyms are listed in the files /usr/include/X11/keysymdef.h and in
/usr/lib/X11/XKeysymDB, or whatever the equivalents are on your system.
arguments:(keysym)
Fx-set-screen-pointer
Set the mouse cursor of SCREEN to the cursor named CURSOR-NAME,
with colors FOREGROUND and BACKGROUND. The string may be any of the
standard cursor names from appendix B of the Xlib manual (also known as
the file <X11/cursorfont.h>) minus the XC_ prefix, or it may be a font
name and glyph index of the form "FONT fontname index [[font] index]",
or it may be a bitmap file acceptable to XmuLocateBitmapFile().
If it is a bitmap file, and if a bitmap file whose name is the name of
the cursor with "msk" exists, then it is used as the mask. For example,
a pair of files may be named "cursor.xbm" and "cursor.xbmmsk".
arguments:(screen cursor_name &optional fg bg)
Fx-open-connection
Open a connection to an X server.
Argument ARGV is a list of strings describing the command line options.
Returns a copy of ARGV from which the arguments used by the Xt code
to open the connect have been removed.
arguments:(argv_list)
Fx-window-id
Get the ID of the X11 window. This gives us a chance to manipulate
the Emacs window from within a different program. Since the id is an
unsigned long, we return it as a string.
arguments:(screen)
Fx-close-current-connection
Close the connection to the current X server.
arguments:()
Fx-debug-mode
With a true arg, put the connection to the X server in synchronous
mode; this is slower. False turns it off.
Do not simply call XSynchronize() from gdb; that won't work.
arguments:(arg)
Vx-gc-pointer-shape
The shape of the mouse-pointer during garbage collection.
If this is nil, then the cursor will not be changed, and echo-area messages
will be used instead.Vbar-cursor
Use vertical bar cursor if non-nil.Vx-screen-defaults
Alist of default screen-creation parameters for X-window screens.
These override what is specified in `~/.Xdefaults' but are overridden
by the arguments to the particular call to `x-create-screen'.Vdefault-screen-name
The default name to assign to newly-created screens.
This can be overridden by arguments to `x-create-screen'.
This must be a string.Vx-emacs-application-class
The X application class of the Emacs process.
This controls, among other things, the name of the `app-defaults' file
that emacs will use. For changes to this variable to take effect, they
must be made before the connection to the X server is initialized, that is,
this variable may only be changed before emacs is dumped, or by setting it
in the file lisp/term/x-win.el.Vx-bitmap-file-path
A list of the directories in which X bitmap files may be found.
If nil, this is initialized from the "*bitmapFilePath" resource.Vx-allow-sendevents
*Non-nil means to allow synthetic events. Nil means they are ignored.
Beware: allowing emacs to process SendEvents opens a big security hole.Fx-selection-reply-timeout-internal
arguments:(arg)
Fx-own-selection-internal
Assert an X selection of the given TYPE with the given VALUE.
TYPE is a symbol, typically PRIMARY, SECONDARY, or CLIPBOARD.
VALUE is typically a string, or a cons of two markers, but may be
anything that the functions on selection-converter-alist know about.
arguments:(selection_name selection_value)
Fx-get-selection-internal
Return text selected from some X window.
SELECTION is a symbol, typically PRIMARY, SECONDARY, or CLIPBOARD.
TYPE is the type of data desired, typically STRING.
arguments:(selection_symbol target_type)
Fx-disown-selection-internal
If we own the named selection, then disown it (make there be no selection).
arguments:(selection &optional time)
Fx-selection-owner-p
Whether the current emacs process owns the given X Selection.
The arg should be the name of the selection in question, typically one of
the symbols PRIMARY, SECONDARY, or CLIPBOARD. (For convenience, the symbol
nil is the same as PRIMARY, and t is the same as SECONDARY.)
arguments:(&optional selection)
Fx-selection-exists-p
Whether there is an owner for the given X Selection.
The arg should be the name of the selection in question, typically one of
the symbols PRIMARY, SECONDARY, or CLIPBOARD. (For convenience, the symbol
nil is the same as PRIMARY, and t is the same as SECONDARY.)
arguments:(&optional selection)
Fx-get-cutbuffer-internal
Returns the value of the named cutbuffer (typically CUT_BUFFER0).
arguments:(buffer)
Fx-store-cutbuffer-internal
Sets the value of the named cutbuffer (typically CUT_BUFFER0).
arguments:(buffer string)
Fx-rotate-cutbuffers-internal
Rotate the values of the cutbuffers by the given number of steps;
positive means move values forward, negative means backward.
arguments:(n)
Vselection-converter-alist
An alist associating selection-types (such as STRING and TIMESTAMP) with
functions. These functions will be called with three args: the name of the
selection (typically PRIMARY, SECONDARY, or CLIPBOARD); a desired type to
which the selection should be converted; and the local selection value
(whatever had been passed to `x-own-selection'). These functions should
return the value to send to the X server (typically a string). A return
value of nil means that the conversion could not be done. A return value
which is the symbol NULL means that a side-effect was executed, and there
is no meaningful return value.Vx-lost-selection-hooks
A function or functions to be called after the X server has notified us
that we have lost the selection. The function(s) will be called with one
argument, a symbol naming the selection (typically PRIMARY, SECONDARY, or
CLIPBOARD.)Vx-sent-selection-hooks
A function or functions to be called after we have responded to some
other client's request for the value of a selection that we own. The
function(s) will be called with four arguments:
- the name of the selection (typically PRIMARY, SECONDARY, or CLIPBOARD);
- the name of the selection-type which we were requested to convert the
selection into before sending (for example, STRING or LENGTH);
- and whether we successfully transmitted the selection.
We might have failed (and declined the request) for any number of reasons,
including being asked for a selection that we no longer own, or being asked
to convert into a type that we don't know about or that is inappropriate.
This hook doesn't let you change the behavior of emacs's selection replies,
it merely informs you that they have happened.Vx-selection-timeout
If the selection owner doens't reply in this many seconds, we give up.
A value of 0 means wait as long as necessary. This is initialized from the
"*selectionTimeout" resource (which is expressed in milliseconds).
Vemacs-version
Version numbers of this version of Emacs.
Vemacs-build-time
Time at which Emacs was dumped out.
Femacs-version
Return string describing the version of Emacs that is running.
Vmode-line-buffer-identification
Mode-line control for identifying the buffer being displayed.
Its default value is "Emacs: %17b". Major modes that edit things
other than ordinary files may change this (e.g. Info, Dired,...)
Vmode-line-process
Mode-line control for displaying info on process status.
Normally nil in most modes, since there is no process to display.
Vmode-line-modified
Mode-line control for displaying whether current buffer is modified.
Vminor-mode-alist
Alist saying how to show minor modes in the mode line.
Each element looks like (VARIABLE STRING);
STRING is included in the mode line iff VARIABLE's value is non-nil.
Vparagraph-start
*Regexp for beginning of a line that starts OR separates paragraphs.
Vparagraph-separate
*Regexp for beginning of a line that separates paragraphs.
If you change this, you may have to change paragraph-start also.
Vsentence-end
*Regexp describing the end of a sentence.
All paragraph boundaries also end sentences, regardless.
Vpage-delimiter
*Regexp describing line-beginnings that separate pages.
Vcase-replace
*Non-nil means query-replace should preserve case in replacements.
Vindent-line-function
Function to indent current line.
Vonly-global-abbrevs
*t means user plans to use global abbrevs only.
Makes the commands to define mode-specific abbrevs define global ones instead.
Vgrep-command
*Name of the command to use to run the grep command;
typically "grep -n" or "egrep -n".
(The "-n" option tells grep to output line numbers.)
Vdired-listing-switches
*Switches passed to `ls' for Dired. MUST contain the `l' option.
Vlpr-switches
*List of strings to pass as extra args to `lpr' when it is invoked.
Vtag-table-alist
*A list which determines which tags files should be active for a
given buffer. This is not really an association list, in that all
elements are checked. The CAR of each element of this list is a
pattern against which the buffer's file name is compared; if it
matches, then the CDR of the list should be the name of the tags
table to use. If more than one element of this list matches the
buffer's file name, then all of the associated tags tables will be
used. Earlier ones will be searched first.
If the CAR of elements of this list are strings, then they are treated
as regular-expressions against which the file is compared (like the
auto-mode-alist). If they are not strings, then they are evaluated.
If they evaluate to non-nil, then the current buffer is considered to
match.
If the CDR of the elements of this list are strings, then they are
assumed to name a TAGS file. If they name a directory, then the string
"TAGS" is appended to them to get the file name. If they are not
strings, then they are evaluated, and must return an appropriate string.
For example:
(setq tag-table-alist
'(("/usr/src/public/perl/" . "/usr/src/public/perl/perl-3.0/")
("\\.el$" . "/usr/local/emacs/src/")
("/jbw/gnu/" . "/usr15/degree/stud/jbw/gnu/")
("" . "/usr/local/emacs/src/")
))
This means that anything in the /usr/src/public/perl/ directory should use
the TAGS file /usr/src/public/perl/perl-3.0/TAGS; and file ending in .el should
use the TAGS file /usr/local/emacs/src/TAGS; and anything in or below the
directory /jbw/gnu/ should use the TAGS file /usr15/degree/stud/jbw/gnu/TAGS.
A file called something like "/usr/jbw/foo.el" would use both the TAGS files
/usr/local/emacs/src/TAGS and /usr15/degree/stud/jbw/gnu/TAGS (in that order)
because it matches both patterns.
If the buffer-local variable `buffer-tag-table' is set, then it names a tags
table that is searched before all others when find-tag is executed from this
buffer.
If there is a file called "TAGS" in the same directory as the file in
question, then that tags file will always be used as well (after the
`buffer-tag-table' but before the tables specified by this list.)
If the variable tags-file-name is set, then the tags file it names will apply
to all buffers (for backwards compatibility.) It is searched first.
Vtags-file-name
*The name of the tags-table used by all buffers.
This is for backward compatibility, and is largely supplanted by the
variable tag-table-alist.
Vshell-prompt-pattern
*Regexp used by Newline command in shell mode to match subshell prompts.
Anything from beginning of line up to the end of what this pattern matches
is deemed to be prompt, and is not reexecuted.
Vledit-save-files
*Non-nil means Ledit should save files before transferring to Lisp.
Vledit-go-to-lisp-string
*Shell commands to execute to resume Lisp job.
Vledit-go-to-liszt-string
*Shell commands to execute to resume Lisp compiler job.
Vdisplay-time-day-and-date
*Non-nil means M-x display-time should display day and date as well as time.
Vauto-mode-alist
Alist of filename patterns vs corresponding major mode functions.
Each element looks like (REGEXP . FUNCTION).
Visiting a file whose name matches REGEXP causes FUNCTION to be called.
Vfont-lock-keywords
*The keywords to highlight.
If this is a list, then elements may be of the forms:
"string" ; a regexp to highlight in the
; `font-lock-keyword-face'.
("string" . integer) ; match N of the regexp will be highlighted
("string" . face-name) ; use the named face
("string" integer face-name) ; both of the above
These regular expressions should not match text which spans lines. Multi-line
patterns will be correctly fontified when \[font-lock-fontify-buffer] is used,
but will not be matched by the auto-fontification that font-lock-mode does,
since it looks at only one line at a time.
The more patterns there are in this list, the slower the initial fontification
of the buffer will be.
Vdiff-switches
*A list of switches to pass to the diff program.
Vkill-emacs-hook
A list of functions (of no args) for `kill-emacs' to call before emacs is
actually killed.
Vrmail-dont-reply-to-names
*A regular expression specifying names to prune in replying to messages.
nil means don't reply to yourself.
Vrmail-default-dont-reply-to-names
A regular expression specifying part of the value of the default value of
the variable `rmail-dont-reply-to-names', for when the user does not set
`rmail-dont-reply-to-names' explicitly. (The other part of the default
value is the user's name.)
It is useful to set this variable in the site customisation file.
Vrmail-primary-inbox-list
*List of files which are inboxes for user's primary mail file ~/RMAIL.
`nil' means the default, which is ("/usr/spool/mail/$USER" "~/mbox")
(the first name varies depending on the operating system,
and the value of the environment variable MAIL overrides it).
Vrmail-ignored-headers
*Gubbish header fields one would rather not see.
Vrmail-delete-after-output
*Non-nil means automatically delete a message that is copied to a file.
Vauto-save-timeout
*Number of seconds idle time before auto-save.
Zero or nil means disable auto-saving due to idleness.
The actual amount of idle time between auto-saves is logarithmically related
to the size of the current buffer. This variable is the number of seconds
after which an auto-save will happen when the current buffer is 50k or less;
the timeout will be 2 1/4 times this in a 200k buffer, 3 3/4 times this in a
1000k buffer, and 4 1/2 times this in a 2000k buffer.
For this variable to have any effect, you must do (require 'timer).
See also the variable `auto-save-interval', which controls auto-saving based
on the number of characters typed.
Vsend-mail-function
Function to call to send the current buffer as mail.
The headers are delimited by a string found in mail-header-separator.
Vmail-self-blind
*Non-nil means insert BCC to self in messages to be sent.
This is done when the message is initialized,
so you can remove or alter the BCC field to override the default.
Vmail-interactive
*Non-nil means when sending a message wait for and display errors.
nil means let mailer mail back a message to report errors.
Vmail-yank-ignored-headers
Delete these headers from old message when it's inserted in a reply.
Vmail-header-separator
*Line used to separate headers from text in messages being composed.
Vmail-archive-file-name
*Name of file to write all outgoing messages in, or nil for none.
Do not use an rmail file here! Instead, use its inbox file.
Vmail-signature-file
File to be inserted at the end of a message. Usually, this file is called
"~/.signature".
Vmail-aliases
Word-abbrev table of mail address aliases.
If this is nil, it means the aliases have not yet been initialized and
should be read from the .mailrc file. (This is distinct from there being
no aliases, which is represented by this being a table with no entries.)
Vmail-abbrev-mailrc-file
Name of file with mail aliases. If nil, ~/.mailrc is used.
Vmail-use-rfc822
*If non-nil, use a full, hairy RFC822 parser on mail addresses.
Otherwise, (the default) use a smaller, somewhat faster and
often-correct parser.
Fquery-replace
Replace some occurrences of FROM-STRING with TO-STRING.
As each match is found, the user must type a character saying
what to do with it. For directions, type \[help-command] at that time.
Preserves case in each replacement if case-replace and case-fold-search
are non-nil and FROM-STRING has no uppercase letters.
Third arg DELIMITED (prefix arg if interactive) non-nil means replace
only matches surrounded by word boundaries.
Fquery-replace-regexp
Replace some things after point matching REGEXP with TO-STRING.
As each match is found, the user must type a character saying
what to do with it. For directions, type \[help-command] at that time.
Preserves case in each replacement if case-replace and case-fold-search
are non-nil and REGEXP has no uppercase letters.
Third arg DELIMITED (prefix arg if interactive) non-nil means replace
only matches surrounded by word boundaries.
In TO-STRING, \& means insert what matched REGEXP,
and \=\<n> means insert what matched <n>th \(...\) in REGEXP.
Fmap-query-replace-regexp
Replace some matches for REGEXP with various strings, in rotation.
The second argument TO-STRINGS contains the replacement strings, separated
by spaces. This command works like `query-replace-regexp' except
that each successive replacement uses the next successive replacement string,
wrapping around from the last such string to the first.
Non-interactively, TO-STRINGS may be a list of replacement strings.
A prefix argument N says to use each replacement string N times
before rotating to the next.
Freplace-string
Replace occurrences of FROM-STRING with TO-STRING.
Preserve case in each match if `case-replace' and `case-fold-search'
are non-nil and FROM-STRING has no uppercase letters.
Third arg DELIMITED (prefix arg if interactive) non-nil means replace
only matches surrounded by word boundaries.
This function is usually the wrong thing to use in a Lisp program.
What you probably want is a loop like this:
(while (search-forward OLD-STRING nil t)
(replace-match REPLACEMENT nil t))
which will run faster and will not set the mark or print anything.
Freplace-regexp
Replace things after point matching REGEXP with TO-STRING.
Preserve case in each match if case-replace and case-fold-search
are non-nil and REGEXP has no uppercase letters.
Third arg DELIMITED (prefix arg if interactive) non-nil means replace
only matches surrounded by word boundaries.
In TO-STRING, \& means insert what matched REGEXP,
and \=\<n> means insert what matched <n>th \(...\) in REGEXP.
This function is usually the wrong thing to use in a Lisp program.
What you probably want is a loop like this:
(while (re-search-forward REGEXP nil t)
(replace-match REPLACEMENT nil nil))
which will run faster and will not set the mark or print anything.
Fisearch-forward-regexp
Do incremental search forward for regular expression.
Like ordinary incremental search except that your input
is treated as a regexp. See \[isearch-forward] for more info.
Fisearch-backward
Do incremental search backward.
With a prefix argument, do an incremental regular expression search instead.
See \[isearch-forward] for more information.
Fisearch-backward-regexp
Do incremental search backward for regular expression.
Like ordinary incremental search except that your input
is treated as a regexp. See \[isearch-forward] for more info.